fix(teams): track wait_until invocation explicitly to detect deduped messages

The previous fix (17009a9) used ``processing_done.done()`` to detect
whether a chat task was scheduled, but ``_resolve_processing`` registers
a ``done_callback`` on the task that fires only on task COMPLETION —
not at the moment ``wait_until`` is invoked. So my check
prematurely resolved ``processing_done`` immediately after
``process_message`` returned (before the task had a chance to run),
which broke 2 tests:

- test_caller_wait_until_raise_does_not_kill_native_streaming
- test_same_thread_concurrent_handlers_clobber_active_stream

Fix: track a separate ``wait_until_invoked`` flag inside
``_chained_wait_until``. After ``process_message`` returns, only resolve
``processing_done`` if ``wait_until`` was NEVER called — that's the
true signal that no chat task was scheduled (deduped/dropped).

23 native-streaming tests pass; full suite passes (modulo the
pre-existing unrelated github_webhook failure).

https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

Author: claude

src/chat_sdk/adapters/teams/adapter.py

@@ -458,8 +458,15 @@ def _on_done(_t: asyncio.Task[Any]) -> None:
                 processing_done.set_result(None)
 
         upstream_wait_until = options.wait_until if options is not None else None
+        # Track whether the chained wait_until fired synchronously during
+        # ``process_message``. Used below to detect deduped/dropped
+        # messages where no chat task was scheduled and we'd otherwise
+        # hang on ``await processing_done``.
+        wait_until_invoked = False
 
         def _chained_wait_until(task: Awaitable[Any]) -> None:
+            nonlocal wait_until_invoked
+            wait_until_invoked = True
             # Resolve our own gate FIRST, before invoking the upstream
             # ``wait_until`` callback. This way, even if the upstream
             # callback raises, blocks, or never fires, ``processing_done``
@@ -494,7 +501,11 @@ def _chained_wait_until(task: Awaitable[Any]) -> None:
             # message wasn't admitted for handling). Resolve the gate
             # immediately so ``await processing_done`` doesn't hang
             # forever — there is no in-flight handler to wait on.
-            if not processing_done.done():
+            # Note: we check ``wait_until_invoked`` rather than
+            # ``processing_done.done()`` because the latter is set via
+            # an ``add_done_callback`` on task COMPLETION; the task is
+            # scheduled but has not run yet at this point.
+            if not wait_until_invoked and not processing_done.done():
                 processing_done.set_result(None)
             try:
                 await processing_done