CB-110: fail an in-flight delegation when its worker vanishes

Companion to CB-109. When a worker disappears mid-turn (pane crash → herdr
*_not_found), the status poller drops the target, which failed only *queued*
messages — a message already DELIVERED is out of the queue, so its send's
rendezvous was left hanging until the 30-min async timeout. Injector.drop now
fires onTurnFailed for a delivered-but-unresolved turn (awaitingCompletion), so
the send resolves as WORKER_FAILED. Reuses the CB-109 resolver path; the failure
reason is neutral to cover both wedge (stuck) and vanish (gone).

bridged/src/main/java/dev/ltms/bridged/inject/CompletionResolver.java

@@ -89,7 +89,9 @@ public final class CompletionResolver implements TurnListener {
             reason = "";
         }
         if (reason.isBlank()) {
-            reason = "worker turn ended in an unrecoverable state (herdr status stuck at unknown)";
+            // No screen to scrape — either the worker is stuck (CB-109) or gone (CB-110).
+            reason = "worker did not reply; its turn ended in an unrecoverable state "
+                    + "(worker unreachable or stuck)";
         }
         if (rendezvous.resolveFailure(target, reason)) {
             log.debug("failed send to {} via turn-stall fallback", target);

bridged/src/main/java/dev/ltms/bridged/inject/Injector.java

@@ -240,20 +240,30 @@ public final class Injector {
     }
 
     /**
-     * Forget a target whose worker is gone, failing every still-queued message so awaiting
-     * callers unblock instead of hanging forever. Futures are completed after the monitor is
-     * released.
+     * Forget a target whose worker is gone, failing every still-queued message so awaiting callers
+     * unblock instead of hanging forever. If a message had already been <em>delivered</em> but its
+     * turn was not yet resolved (CB-110 — the worker vanished mid-turn, e.g. its pane crashed), fire
+     * {@link TurnListener#onTurnFailed} for it: a delivered message is no longer in the queue, so
+     * failing queued waiters alone would leave that send's rendezvous hanging until the async
+     * timeout. Futures and listeners are completed after the monitor is released.
      */
     public void drop(String target, Throwable cause) {
         Target t = targets.remove(target);
         if (t == null) return;
         List<Pending> pending;
+        boolean hadDeliveredTurn;
         synchronized (t) {
             pending = new ArrayList<>(t.queue);
             t.queue.clear();
+            hadDeliveredTurn = t.awaitingCompletion;
+            t.awaitingCompletion = false;
+            t.awaitingPickup = false;
         }
         for (Pending p : pending) {
             p.delivered().completeExceptionally(cause);
         }
+        if (hadDeliveredTurn) {
+            turnListener.onTurnFailed(target);
+        }
     }
 }