shared map cache was unlinking, now doesnt

[relh]

Summary

• Fixed a shared map cache bug where the multiprocessing resource_tracker would auto-unlink shared-memory map blocks when worker processes exited, leaving stale registry entries and forcing constant map rebuilds.
• We now unregister each shared-memory block from the tracker when creating or attaching in SharedMapCache, keeping cache entries valid across processes and eliminating the rebuild thrash.

Here’s what we added and why it’s needed:

• Import resource_tracker (best-effort)
  Allows us to talk to Python’s multiprocessing resource tracker, which automatically unregisters shared-memory blocks when a process exits. On platforms without it, we no-op.
• _untrack_shared_memory helper
  Central method that unregisters a SharedMemory block from the resource tracker. Without this, every process that attaches to an existing block registers it, and its exit unlinks the block, leaving the cache
  pointing at a missing segment and triggering rebuilds.
• Untrack after create
  Right after creating a new shared-memory block, we unregister it. This prevents the creating process’s eventual exit from unlinking the block and invalidating the cache.
• Untrack when reusing existing SHM (FileExistsError path)
  If a block already exists (another process made it), we attach and immediately unregister; otherwise that attaching process would be registered to unlink the block on exit, causing thrash.
• Untrack when re-attaching on reconstruction
  When reconstructing maps from registry metadata, we may attach to an existing block. We unregister after attaching so that reader processes don’t get ownership and inadvertently unlink the block on exit.