Reuse `_parent_chan` to unregister from parent-registrar

When the parent actor IS the registrar, reuse the existing parent
channel for `unregister_actor` RPC instead of opening a new connection
via `get_registry()`. This avoids failures when the registrar's listener
socket is already closed during teardown (e.g. UDS transport unlinks the
socket file rapidly).

Deats,
- detect `parent_is_reg` by comparing `_parent_chan.raddr` against
  `reg_addrs` and if matched, create a `Portal(rent_chan)` directly
  instead of `async with get_registry()`.
- rename `failed` -> `failed_unreg` for clarity.

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

tractor/runtime/_runtime.py

@@ -1845,13 +1845,46 @@ async def async_main(
             and
             not actor.is_registrar
         ):
-            failed: bool = False
+            failed_unreg: bool = False
+            rent_chan: Channel|None = actor._parent_chan
+
+            # XXX check if the parent IS the registrar so we can
+            # reuse the existing channel (avoids opening a new
+            # connection which fails when the listener socket is
+            # already closed, e.g. UDS transport unlinks the socket
+            # file during teardown).
+            parent_is_reg: bool = False
+            if (
+                rent_chan is not None
+                and
+                rent_chan.connected()
+            ):
+                pchan_raddr: Address|None = rent_chan.raddr
+                if pchan_raddr is not None:
+                    reg_addr: Address
+                    for reg_addr in actor.reg_addrs:
+                        if (
+                            pchan_raddr.unwrap()
+                            ==
+                            tuple(reg_addr)
+                        ):
+                            parent_is_reg = True
+                            break
+
             for addr in actor.reg_addrs:
                 waddr = wrap_address(addr)
                 assert waddr.is_valid
                 with trio.move_on_after(0.5) as cs:
                     cs.shield = True
                     try:
+                        if parent_is_reg:
+                            reg_portal = Portal(rent_chan)
+                            await reg_portal.run_from_ns(
+                                'self',
+                                'unregister_actor',
+                                uid=actor.aid.uid,
+                            )
+                        else:
                             async with get_registry(
                                 addr,
                             ) as reg_portal:
@@ -1861,11 +1894,12 @@ async def async_main(
                                     uid=actor.aid.uid,
                                 )
                     except OSError:
-                        failed = True
+                        failed_unreg = True
-                if cs.cancelled_caught:
-                    failed = True
 
-                if failed:
+                if cs.cancelled_caught:
+                    failed_unreg = True
+
+                if failed_unreg:
                     teardown_report += (
                         f'-> Failed to unregister {actor.name} from '
                         f'registar @ {addr}\n'