fix(transport): use spawn_detached for stderr reader (trio nursery corruption) (#885)

## Problem

When `query()` is iterated inside a trio nursery task with
`options.stderr`
set, cancelling or breaking out of the iteration can raise:

RuntimeError: Nursery stack corrupted: Nursery surrounding <Task ...>
    was closed before the task exited

`SubprocessCLITransport.connect()` spawns the stderr reader by manually
calling `__aenter__` on an `anyio.TaskGroup`:

```python
self._stderr_task_group = anyio.create_task_group()
await self._stderr_task_group.__aenter__()
self._stderr_task_group.start_soon(self._handle_stderr)
```

On the trio backend this pushes a nursery onto the calling task's
nursery
stack. The matching `__aexit__` lives in `close()`, which is reached via
`process_query`'s `finally` → `inner.aclose()` → `transport.close()`. If
the
caller cancels the iteration (e.g. wraps the `async for` in a
`CancelScope`
and breaks early), the awaits along that cleanup path checkpoint while
the
scope is cancelled and re-raise `Cancelled` before `__aexit__` runs. The
nursery is left on the task's stack; when the task exits, trio raises
the
corruption error.

This is the same task-affinity hazard that
`_task_compat.spawn_detached()`
already solves for the read loop (`Query._read_task`). The stderr reader
predates that helper and was not migrated.

## Fix

Spawn the stderr reader via `spawn_detached()` and clean it up with
`TaskHandle.cancel()` + `await wait()`, matching the read-loop pattern
in
`_internal/query.py`. This removes the manual `__aenter__`/`__aexit__`
and
the trio task-affinity requirement.

## Repro

```python
import trio
from claude_agent_sdk import query, ClaudeAgentOptions

async def one():
    opts = ClaudeAgentOptions(stderr=lambda line: None, max_turns=1)
    with trio.CancelScope() as cs:
        async for msg in query(prompt="hi", options=opts):
            cs.cancel()  # early-break after first message

async def main():
    async with trio.open_nursery() as n:
        for _ in range(5):
            n.start_soon(one)

trio.run(main)
```

Before: `RuntimeError: Nursery stack corrupted` from the nursery
`__aexit__`.
After: clean exit.

Author: dmckennirey-ant

src/claude_agent_sdk/_internal/transport/subprocess_cli.py

@@ -13,14 +13,14 @@
 from typing import Any, cast
 
 import anyio
-import anyio.abc
 from anyio.abc import Process
 from anyio.streams.text import TextReceiveStream, TextSendStream
 
 from ..._errors import CLIConnectionError, CLINotFoundError, ProcessError
 from ..._errors import CLIJSONDecodeError as SDKJSONDecodeError
 from ..._version import __version__
 from ...types import ClaudeAgentOptions, SystemPromptFile, SystemPromptPreset
+from .._task_compat import TaskHandle, spawn_detached
 from . import Transport
 
 logger = logging.getLogger(__name__)
@@ -50,7 +50,7 @@ def __init__(
         self._stdout_stream: TextReceiveStream | None = None
         self._stdin_stream: TextSendStream | None = None
         self._stderr_stream: TextReceiveStream | None = None
-        self._stderr_task_group: anyio.abc.TaskGroup | None = None
+        self._stderr_task: TaskHandle | None = None
         self._ready = False
         self._exit_error: Exception | None = None  # Track process exit errors
         self._max_buffer_size = (
@@ -463,10 +463,10 @@ async def connect(self) -> None:
             # Setup stderr stream if piped
             if stderr_dest is PIPE and self._process.stderr:
                 self._stderr_stream = TextReceiveStream(self._process.stderr)
-                # Start async task to read stderr
-                self._stderr_task_group = anyio.create_task_group()
-                await self._stderr_task_group.__aenter__()
-                self._stderr_task_group.start_soon(self._handle_stderr)
+                # Spawn the stderr reader via spawn_detached (not a manually-
+                # entered TaskGroup) so cleanup has no trio task-affinity —
+                # same pattern as Query._read_task.
+                self._stderr_task = spawn_detached(self._handle_stderr())
 
             # Setup stdin for streaming (always used now)
             if self._process.stdin:
@@ -515,12 +515,12 @@ async def close(self) -> None:
             self._ready = False
             return
 
-        # Close stderr task group if active
-        if self._stderr_task_group:
+        # Cancel stderr reader if active
+        if self._stderr_task is not None and not self._stderr_task.done():
+            self._stderr_task.cancel()
             with suppress(Exception):
-                self._stderr_task_group.cancel_scope.cancel()
-                await self._stderr_task_group.__aexit__(None, None, None)
-            self._stderr_task_group = None
+                await self._stderr_task.wait()
+        self._stderr_task = None
 
         # Close stdin stream (acquire lock to prevent race with concurrent writes)
         async with self._write_lock: