Make run() post on both trips at cross-executor boundaries

run_awaitable_ex::await_suspend and the return trampoline's
final_suspend both called dispatch(). On executors with a
thread-check fast path (strand, blocking_executor) dispatch can
fire an inline symmetric transfer, which does not enqueue the
target and does not give the caller's executor a fresh tick on
the return. run(ex)(task) then fails to actually run task on ex
and leaves the caller resuming on the wrong frame.

Switch both trips to post + std::noop_coroutine(). Also rename
dispatch_trampoline to boundary_trampoline; the type's purpose
is bridging the executor boundary, and the old name named a
mechanism that no longer applies.

The five previously-failing tests in boost.capy.run.priority,
boost.capy.ex.run, and boost.capy.strand now pass; full suite
green at 76743 assertions.

Author: sgerbino

doc/continuation-rationale.md

@@ -432,7 +432,7 @@ their own `continuation`:
 
 - `when_all_core::continuation_` (parent handle for combinator)
 - `when_any_core::continuation_` (same)
-- `dispatch_trampoline::parent_` (cross-executor trampoline)
+- `boundary_trampoline::parent_` (cross-executor trampoline)
 - `run_awaitable_ex::task_cont_` (initial task dispatch)
 - `run_async_trampoline::task_cont_` (same)
 

include/boost/capy/detail/await_suspend_helper.hpp

@@ -35,9 +35,10 @@ namespace detail {
         The return value is written to the now-destroyed frame.
 
     @li `await_suspend` hands the continuation to another thread
-        via `executor::dispatch()`, which may resume the parent.
-        The parent can destroy this frame before the runtime reads
-        `__$ReturnUdt$` (e.g. `dispatch_trampoline` final_suspend).
+        via an executor handoff (e.g. `post()` or `dispatch()`),
+        which may resume the parent. The parent can destroy this
+        frame before the runtime reads `__$ReturnUdt$` (e.g.
+        `boundary_trampoline` final_suspend).
 
     On MSVC this function calls `h.resume()` on the current stack
     and returns `void`, causing unconditional suspension. The

include/boost/capy/ex/run.hpp

@@ -70,17 +70,17 @@ namespace boost::capy::detail {
 
     The trampoline never touches the task's result.
 */
-struct BOOST_CAPY_CORO_DESTROY_WHEN_COMPLETE dispatch_trampoline
+struct BOOST_CAPY_CORO_DESTROY_WHEN_COMPLETE boundary_trampoline
 {
     struct promise_type
         : frame_alloc_mixin
     {
         executor_ref caller_ex_;
         continuation parent_;
 
-        dispatch_trampoline get_return_object() noexcept
+        boundary_trampoline get_return_object() noexcept
         {
-            return dispatch_trampoline{
+            return boundary_trampoline{
                 std::coroutine_handle<promise_type>::from_promise(*this)};
         }
 
@@ -96,8 +96,9 @@ struct BOOST_CAPY_CORO_DESTROY_WHEN_COMPLETE dispatch_trampoline
                 auto await_suspend(
                     std::coroutine_handle<>) noexcept
                 {
+                    p_->caller_ex_.post(p_->parent_);
                     return detail::symmetric_transfer(
-                        p_->caller_ex_.dispatch(p_->parent_));
+                        std::noop_coroutine());
                 }
 
                 void await_resume() const noexcept {}
@@ -111,20 +112,20 @@ struct BOOST_CAPY_CORO_DESTROY_WHEN_COMPLETE dispatch_trampoline
 
     std::coroutine_handle<promise_type> h_{nullptr};
 
-    dispatch_trampoline() noexcept = default;
+    boundary_trampoline() noexcept = default;
 
-    ~dispatch_trampoline()
+    ~boundary_trampoline()
     {
         if(h_) h_.destroy();
     }
 
-    dispatch_trampoline(dispatch_trampoline const&) = delete;
-    dispatch_trampoline& operator=(dispatch_trampoline const&) = delete;
+    boundary_trampoline(boundary_trampoline const&) = delete;
+    boundary_trampoline& operator=(boundary_trampoline const&) = delete;
 
-    dispatch_trampoline(dispatch_trampoline&& o) noexcept
+    boundary_trampoline(boundary_trampoline&& o) noexcept
         : h_(std::exchange(o.h_, nullptr)) {}
 
-    dispatch_trampoline& operator=(dispatch_trampoline&& o) noexcept
+    boundary_trampoline& operator=(boundary_trampoline&& o) noexcept
     {
         if(this != &o)
         {
@@ -135,11 +136,11 @@ struct BOOST_CAPY_CORO_DESTROY_WHEN_COMPLETE dispatch_trampoline
     }
 
 private:
-    explicit dispatch_trampoline(std::coroutine_handle<promise_type> h) noexcept
+    explicit boundary_trampoline(std::coroutine_handle<promise_type> h) noexcept
         : h_(h) {}
 };
 
-inline dispatch_trampoline make_dispatch_trampoline()
+inline boundary_trampoline make_boundary_trampoline()
 {
     co_return;
 }
@@ -170,7 +171,7 @@ struct [[nodiscard]] run_awaitable_ex
     frame_memory_resource<Alloc> resource_;
     std::conditional_t<InheritStopToken, std::monostate, std::stop_token> st_;
     io_env env_;
-    dispatch_trampoline tr_;
+    boundary_trampoline tr_;
     continuation task_cont_;
     Task inner_;  // Last: destroyed first, while env_ is still valid
 
@@ -224,7 +225,7 @@ struct [[nodiscard]] run_awaitable_ex
 
     std::coroutine_handle<> await_suspend(std::coroutine_handle<> cont, io_env const* caller_env)
     {
-        tr_ = make_dispatch_trampoline();
+        tr_ = make_boundary_trampoline();
         tr_.h_.promise().caller_ex_ = caller_env->executor;
         tr_.h_.promise().parent_.h = cont;
 
@@ -245,7 +246,8 @@ struct [[nodiscard]] run_awaitable_ex
 
         p.set_environment(&env_);
         task_cont_.h = h;
-        return ex_.dispatch(task_cont_);
+        ex_.post(task_cont_);
+        return std::noop_coroutine();
     }
 
     // Non-copyable