Drop the vestigial `._ria_nursery`

Step B of the `._ria_nursery` removal (issue #477; see
`ai/conc-anal/ria_nursery_removal_plan.md`). With step A having
rerouted `.run_in_actor()` children onto the daemon nursery,
the 2ndary "run-in-actor" nursery spawns nothing and its stored
ref is never read — pure dead weight,

- collapse the inner `async with trio.open_nursery() as
  ria_nursery` layer in
  `_open_and_supervise_one_cancels_all_nursery`; `da_nursery` is
  now the single nursery for ALL subactors.
- `ActorNursery.__init__` loses the `ria_nursery` param + the
  `self._ria_nursery` attr; `start_actor()` loses its `nursery=`
  escape-hatch (spawns via `self._da_nursery` directly).
- `._cancel_after_result_on_exit` stays — still the ria-child
  discriminator for `_reap_ria_portals()`.

Behavior-preserving: a zero-task `trio.open_nursery()` only adds
a checkpoint. The two error handlers are KEPT (now nested under
the single nursery); merging them changes error/cancel
propagation and is deferred to its own PR (TODO left at the
outer `except`).

Prompt-IO: ai/prompt-io/claude/20260702T172233Z_5cd190c5_prompt_io.md

(this patch was generated in some part by [`claude-code`][claude-code-gh])
[claude-code-gh]: https://github.com/anthropics/claude-code

tractor/runtime/_supervise.py

@@ -199,7 +199,6 @@ class ActorNursery:
         self,
         # TODO: maybe def these as fields of a struct looking type?
         actor: Actor,
-        ria_nursery: trio.Nursery,
         da_nursery: trio.Nursery,
         errors: dict[tuple[str, str], BaseException],
 
@@ -233,14 +232,12 @@ class ActorNursery:
         # and syncing purposes to any actor opened nurseries.
         self._implicit_runtime_started: bool = False
 
-        # TODO: remove the `.run_in_actor()` API and thus this 2ndary
-        # nursery when that API get's moved outside this primitive!
-        self._ria_nursery = ria_nursery
-
         # TODO, factor this into a .hilevel api!
         #
         # portals spawned with ``run_in_actor()`` are
-        # cancelled when their "main" result arrives
+        # cancelled when their "main" result arrives. Reaped by
+        # `_reap_ria_portals()` at nursery-block exit now that
+        # the 2ndary `._ria_nursery` is gone (see issue #477).
         self._cancel_after_result_on_exit: set = set()
 
         # trio.Nursery-like cancel (request) statuses
@@ -298,11 +295,6 @@ class ActorNursery:
         debug_mode: bool|None = None,
         infect_asyncio: bool = False,
         inherit_parent_main: bool = True,
-
-        # TODO: ideally we can rm this once we no longer have
-        # a `._ria_nursery` since the dependent APIs have been
-        # removed!
-        nursery: trio.Nursery|None = None,
         proc_kwargs: dict[str, typing.Any] | None = None,
 
     ) -> Portal:
@@ -364,10 +356,8 @@ class ActorNursery:
 
         # start a task to spawn a process
         # blocks until process has been started and a portal setup
-        nursery: trio.Nursery = nursery or self._da_nursery
-
         # XXX: the type ignore is actually due to a `mypy` bug
-        return await nursery.start(  # type: ignore
+        return await self._da_nursery.start(  # type: ignore
             partial(
                 _spawn.new_proc,
                 name,
@@ -639,37 +629,22 @@ async def _open_and_supervise_one_cancels_all_nursery(
     # the collection of errors retreived from spawned sub-actors
     errors: dict[tuple[str, str], BaseException] = {}
 
-    # This is the outermost level "deamon actor" nursery. It is awaited
+    # The single "daemon actor" nursery into which ALL subactors
-    # **after** the below inner "run in actor nursery". This allows for
+    # are spawned — both `.start_actor()` daemons AND
-    # handling errors that are generated by the inner nursery in
+    # `.run_in_actor()` one-shots. The latter's result-reaping now
-    # a supervisor strategy **before** blocking indefinitely to wait for
+    # runs via `_reap_ria_portals()` at block-exit rather than a
-    # actors spawned in "daemon mode" (aka started using
+    # 2ndary `._ria_nursery` (see the #477 removal); errors from
-    # `ActorNursery.start_actor()`).
+    # this nursery bubble up to the caller.
-
-    # errors from this daemon actor nursery bubble up to caller
     async with (
         collapse_eg(),
         trio.open_nursery() as da_nursery,
-    ):
-        try:
-            # This is the inner level "run in actor" nursery. It is
-            # awaited first since actors spawned in this way (using
-            # `ActorNusery.run_in_actor()`) are expected to only
-            # return a single result and then complete (i.e. be canclled
-            # gracefully). Errors collected from these actors are
-            # immediately raised for handling by a supervisor strategy.
-            # As such if the strategy propagates any error(s) upwards
-            # the above "daemon actor" nursery will be notified.
-            async with (
-                collapse_eg(),
-                trio.open_nursery() as ria_nursery,
     ):
         an = ActorNursery(
             actor,
-                    ria_nursery,
             da_nursery,
             errors
         )
+        try:
             try:
                 # spawning of actors happens in the caller's scope
                 # after we yield upwards
@@ -785,15 +760,14 @@ async def _open_and_supervise_one_cancels_all_nursery(
                             ria_children=ria_children,
                         )
 
-            # ria_nursery scope end
+        # Safety-net handler for anything escaping the inner
-
+        # `except BaseException` above (e.g. a `trio.Cancelled`
-        # TODO: this is the handler around the ``.run_in_actor()``
+        # during its non-shielded debugger-wait, or a failure
-        # nursery. Ideally we can drop this entirely in the future as
+        # inside the shielded teardown itself). Post-#477 the
-        # the whole ``.run_in_actor()`` API should be built "on top of"
+        # 2ndary `._ria_nursery` (and its dedicated handler) is
-        # this lower level spawn-request-cancel "daemon actor" API where
+        # gone; this now guards the single daemon nursery scope.
-        # a local in-actor task nursery is used with one-to-one task
+        # TODO: can this be merged into the inner handler now that
-        # + `await Portal.run()` calls and the results/errors are
+        # there's only one nursery? (higher-risk, own PR)
-        # handled directly (inline) and errors by the local nursery.
         except (
             Exception,
             BaseExceptionGroup,