Clarify recursive one-shot spawning test

Handle the child RPC leaf as an early return, then leave the root-only
runtime and recursive one-shot flow unindented. Rename the helper for
that behavior and document why RPC namespace lookup requires it to
remain import-addressable at module scope.

Review: PR #484 (goodboy)
https://github.com/goodboy/tractor/pull/484#discussion_r3859956375

(this patch was generated in some part by `opencode` using `gpt-5.6-sol` (`openai`))

tests/test_spawning.py

@@ -26,17 +26,31 @@ data_to_pass_down = {
 }
 
 
-async def spawn(
+async def run_same_func_in_child(
     should_be_root: bool,
     data: dict,
     reg_addr: tuple[str, int],
 
     debug_mode: bool = False,
 ):
+    '''
+    Invoke this same module-scoped RPC target in a child actor.
+
+    RPC targets cross IPC as `module:name` namespace paths, so this
+    helper must remain import-addressable at module scope instead of
+    being nested inside the test. The root invocation boots a runtime
+    and recursively calls this function as a one-shot child endpoint;
+    the child branch returns the result.
+
+    '''
     await trio.sleep(0.1)
     actor = tractor.current_actor(err_on_no_runtime=False)
 
-    if should_be_root:
+    if not should_be_root:
+        assert actor is not None
+        assert actor.is_registrar == should_be_root
+        return 10
+
     assert actor is None  # no runtime yet
     async with (
         tractor.open_root_actor(
@@ -48,11 +62,11 @@ async def spawn(
         actor: tractor.Actor = tractor.current_actor()
         assert actor.is_registrar == should_be_root
 
-            # recursively spawn this same `spawn()` fn as the lone
+        # recursively spawn this same function as the lone
         # task of a one-shot child subactor and get its result.
         result = await tractor.to_actor.run(
             partial(
-                    spawn,
+                run_same_func_in_child,
                 should_be_root=False,
                 data=data_to_pass_down,
                 reg_addr=reg_addr,
@@ -66,9 +80,6 @@ async def spawn(
         )
         assert result == 10
         return result
-    else:
-        assert actor.is_registrar == should_be_root
-        return 10
 
 
 def test_to_actor_run_same_func_in_child(
@@ -77,7 +88,7 @@ def test_to_actor_run_same_func_in_child(
 ):
     result = trio.run(
         partial(
-            spawn,
+            run_same_func_in_child,
             should_be_root=True,
             data=data_to_pass_down,
             reg_addr=reg_addr,