prepare-sync: clear active-span ContextVar after detach

PR-C.3 review fixup. The cleared spec lifecycle reasoning at
the coord thread covered only the happy path: "ContextVar gets
overwritten on the next prepare_sync." If a subsequent
prepare_sync raises or early-returns without publishing — for
any reason — the engine reads the previous node's span and
attaches it around the new node's body, producing wrong log
correlation.

Bound the "ContextVar is set" window to the node-body scope by
clearing it to None in innermost's finally right after the OTel
detach (both _step_function_node's and _step_fan_out_node's
paths). Between dispatches and during merge / completed-event
dispatch the ContextVar is now None, so a failing or
early-returning prepare_sync can't reveal a stale span when the
engine reads. Lifecycle ownership stays with the attach/detach
scope rather than fanning out across observers in _dispatch.

Updated current_active_observer_span's docstring to reflect the
narrower lifecycle.

Author: chris-colinsky

src/openarmature/graph/compiled.py

@@ -64,6 +64,7 @@
     _reset_invocation_id,
     _reset_namespace_prefix,
     _set_active_dispatch,
+    _set_active_observer_span,
     _set_active_observers,
     _set_attempt_index,
     _set_correlation_id,
@@ -744,7 +745,11 @@ async def innermost(s: Any) -> Mapping[str, Any]:
                 # the node body — before any ``await`` — pick up the
                 # right trace_id/span_id via OTel's LoggingHandler.
                 # Detach in ``finally`` so retries / merge / completed
-                # dispatch don't run with the span still active.
+                # dispatch don't run with the span still active, and
+                # clear ``current_active_observer_span`` to ``None`` so
+                # the next dispatch that raises or early-returns from
+                # ``prepare_sync`` can't reveal this node's span as a
+                # stale value to the engine's read.
                 otel_token = _attach_active_observer_span()
                 try:
                     try:
@@ -763,6 +768,7 @@ async def innermost(s: Any) -> Mapping[str, Any]:
                         raise
                 finally:
                     _detach_active_observer_span(otel_token)
+                    _set_active_observer_span(None)
 
                 try:
                     merged = _merge_partial(s, partial, self.reducers, current)
@@ -1112,7 +1118,10 @@ async def innermost(s: Any) -> Mapping[str, Any]:
                 # trace_id/span_id. Per-instance bodies get their own
                 # attach inside their ``_step_function_node``
                 # innermost when the recursive invocation hits leaf
-                # nodes.
+                # nodes. ``finally`` clears the ContextVar so a later
+                # dispatch whose ``prepare_sync`` raises or early-
+                # returns can't reveal this fan-out's span as a stale
+                # value to the engine's read.
                 otel_token = _attach_active_observer_span()
                 try:
                     try:
@@ -1149,6 +1158,7 @@ async def innermost(s: Any) -> Mapping[str, Any]:
                         raise wrapped from e
                 finally:
                     _detach_active_observer_span(otel_token)
+                    _set_active_observer_span(None)
 
                 try:
                     merged = _merge_partial(s, partial, self.reducers, current)

src/openarmature/observability/correlation.py

@@ -330,6 +330,13 @@ def current_active_observer_span() -> object | None:
     on the first line, before any ``await`` — pick up the span's
     trace_id/span_id via OTel's ``LoggingHandler``.
 
+    Lifecycle: the value is ``None`` outside a node-body scope (between
+    dispatches, during merge, during completed-event dispatch). The
+    engine's ``innermost`` clears it to ``None`` in its ``finally``
+    block right after the OTel detach — so a subsequent
+    ``prepare_sync`` that raises or early-returns can't reveal a stale
+    span from a previous node when the engine reads.
+
     Backend coupling note: typed as ``object | None`` so this primitive
     works in installs without the ``[otel]`` extras. OTel observers
     write OpenTelemetry ``Span`` instances; the engine treats the