Add P3352R3 sender compatibility section to corosio paper

Author: vinniefalco

doc/research/corosio.md

@@ -203,7 +203,36 @@ coro dispatch(coro h) const
 
 If the executor must post rather than dispatch (cross-thread), it returns `std::noop_coroutine()`.
 
-### 5.2 The Task Type
+### 5.2 Sender/Receiver Compatibility
+
+The design is compatible with P3352R3 and `std::execution`. The `dispatch()` method returns a `std::coroutine_handle<>` that can be used in two ways:
+
+- **Symmetric transfer** (coroutine context): Return the handle from `await_suspend`
+- **Explicit resume** (sender context): Call `handle.resume()` directly
+
+```cpp
+// In a sender's completion:
+ex.dispatch(continuation).resume();
+```
+
+If `dispatch()` posts work rather than dispatching inline, it returns `std::noop_coroutine()`. Calling `.resume()` on this is defined as a no-op, making the API safe in all contexts:
+
+```cpp
+coro dispatch(coro h) const
+{
+    return h;  // Return for symmetric transfer OR explicit resume
+}
+
+// Coroutine caller:
+return ex.dispatch(h);        // Symmetric transfer
+
+// Sender/callback caller:
+ex.dispatch(h).resume();      // Explicit resume, noop if posted
+```
+
+This means one executor interface serves both coroutines and senders with no conditional code paths.
+
+### 5.3 The Task Type
 
 The `task` type represents a lazy, composable coroutine:
 
@@ -386,6 +415,7 @@ HALO (Heap Allocation eLision Optimization) can sometimes inline coroutine frame
 | Runtime (deep) | Degrades with type erasure | Stable, scales well |
 | Allocations | 0 (native) to many (erased) | Predictable (1 per coroutine) |
 | Handle overhead | N/A | Zero (`handle<void>` = `handle<T>`) |
+| Sender compatibility | N/A | Native (`dispatch().resume()` pattern) |
 | Code Readability | Callback chains | Linear `co_await` sequences |
 | Debugging | Stack traces fragmented | Stack traces fragmented |
 | Encapsulation | Poor (leaky templates) | Excellent (hidden state) |
@@ -416,5 +446,6 @@ The future of asynchronous C++ is not callbacks with ever-more-elaborate templat
 1. N4680 - C++ Extensions for Coroutines
 2. P0443R14 - A Unified Executors Proposal for C++
 3. P2300R7 - std::execution
-4. Boost.Asio documentation on composed operations
-5. Lewis Baker, "Asymmetric Transfer" blog series
+4. P3352R3 - std::execution integration with coroutines
+5. Boost.Asio documentation on composed operations
+6. Lewis Baker, "Asymmetric Transfer" blog series