fix(async): address review feedback on current-node tracking

- resume_and_drain now takes an explicit restore_to parameter so the
  correct previous node is restored even after handle_subtask_result /
  deliver_deferred overwrite the thread-local
- async_node::current() returns const async_node* to prevent mutation
  of the live runtime node through the diagnostic API

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 16bit-ykiko

include/eventide/async/runtime/frame.h

@@ -16,12 +16,18 @@
 
 namespace eventide {
 
+class async_node;
 class sync_primitive;
 
 namespace detail {
 
 /// Resume a coroutine and immediately drain any deferred root-frame destruction.
-void resume_and_drain(std::coroutine_handle<> handle);
+/// @param restore_to  The async_node* to write back into the thread-local
+///                    current-node slot after the resumed chain returns.
+///                    Callers must capture this **before** any call to
+///                    handle_subtask_result / deliver_deferred, which
+///                    overwrite the slot as part of symmetric-transfer setup.
+void resume_and_drain(async_node* restore_to, std::coroutine_handle<> handle);
 
 }  // namespace detail
 
@@ -124,7 +130,7 @@ class async_node {
 
     /// Returns the async_node whose coroutine body is currently executing on
     /// this thread, or nullptr if no coroutine is active.
-    static async_node* current() noexcept;
+    const static async_node* current() noexcept;
 
     /// Convenience: calls dump_dot() on the current node.  Returns an empty
     /// string if no coroutine is active.

src/async/runtime/frame.cpp

@@ -20,7 +20,7 @@ async_node* detail::current_node() noexcept {
     return current_running_node;
 }
 
-async_node* async_node::current() noexcept {
+const async_node* async_node::current() noexcept {
     return current_running_node;
 }
 
@@ -63,11 +63,10 @@ void drain_pending_destroys() {
 
 }  // namespace
 
-void detail::resume_and_drain(std::coroutine_handle<> handle) {
+void detail::resume_and_drain(async_node* restore_to, std::coroutine_handle<> handle) {
     if(handle) {
-        auto* prev = current_running_node;
         handle.resume();
-        current_running_node = prev;
+        current_running_node = restore_to;
     }
 #if ETD_WORKAROUND_MSVC_COROUTINE_ASAN_UAF
     drain_pending_destroys();
@@ -137,8 +136,9 @@ void async_node::cancel() {
             return;
         }
 
+        auto* prev = current_running_node;
         auto next = awaiter->handle_subtask_result(link);
-        detail::resume_and_drain(next);
+        detail::resume_and_drain(prev, next);
     };
 
     switch(kind) {
@@ -177,8 +177,9 @@ void async_node::cancel() {
                 break;
             }
 
+            auto* prev = current_running_node;
             auto next = self->deliver_deferred();
-            detail::resume_and_drain(next);
+            detail::resume_and_drain(prev, next);
             break;
         }
 
@@ -217,8 +218,9 @@ void system_op::complete() noexcept {
     if(!parent) {
         return;
     }
+    auto* prev = current_running_node;
     auto next = parent->handle_subtask_result(this);
-    detail::resume_and_drain(next);
+    detail::resume_and_drain(prev, next);
 }
 
 /// Wires this node as a child of `awaiter`. For Task nodes, sets state

src/async/runtime/sync.cpp

@@ -63,8 +63,9 @@ bool sync_primitive::cancel_waiter(waiter_link* link) noexcept {
     // than first stashing raw waiter pointers into a temporary container.
     link->state = async_node::Cancelled;
     link->policy = static_cast<async_node::Policy>(link->policy | async_node::InterceptCancel);
+    auto* prev = detail::current_node();
     auto next = awaiting->handle_subtask_result(link);
-    detail::resume_and_drain(next);
+    detail::resume_and_drain(prev, next);
     return true;
 }