tka: avoid quadratic filesystem scans - #20736

Since #17567, FS.ChildAUMs derives child relationships by scanning and decoding every active AUM file. This avoids reading child metadata from a soft-deleted parent. However, authority reconstruction and compaction invoke ChildAUMs repeatedly during graph traversal, making filesystem work quadratic in the number of AUMs.

Instrumenting Open with an 824-AUM production store recorded 826 full scans and 680,624 decoded entries. The operation took 118.5 seconds using Tailscale 1.98.9 on a managed macOS host with Microsoft Defender. Because Open runs while LocalBackend.mu is held, the delay stalled event subscribers and triggered the 45-second RequestStatus watchdog.

This change builds an active-AUM hash index and a parent-to-child hash index in a single filesystem scan. Heads, ChildAUMs, and AllAUMs use the indexes to avoid further full-store scans. AUM values returned to callers are still decoded from disk on demand, preserving the filesystem store's existing value-isolation behavior. The cache retains one hash entry and approximately one parent-to-child edge per active AUM; it does not retain decoded AUM contents.

The indexes belong to a single FS instance. Mutations made through that instance—including commits, purges, and RemoveAll—invalidate them. Known callers and the related storage design assume one owner per node-local directory. If callers share a directory between FS instances or modify it directly, graph changes are not reflected in an instance's indexes until they are invalidated or the instance is reopened. The filesystem remains the durable source of truth, and the disk format and compaction retention behavior remain unchanged.

The benchmark materializes a valid 825-AUM authority in an FS store. On the affected macOS host, the unpatched benchmark took 124.36 seconds. This is within 5% of the 118.5 seconds measured with the production AUM data. AUM generation and filesystem writes occur before the timer starts. Each timed iteration creates a fresh FS over the existing records, so it includes index construction but does not reuse an index from an earlier iteration.

Synthetic 825-AUM benchmark results:

On Linux/ext3, cumulative Go heap allocation per Open drops from 1.98 GB to 8.78 MB, and the number of heap allocations drops from 20.8 million to about 80,800. These are benchmark B/op and allocs/op values, not retained heap or bytes read from disk. The Linux results show the quadratic cost without Defender, while the affected-host process samples are consistent with Defender amplifying the filesystem overhead.

Tests cover rebuilding the indexes after a commit, invalidating them during RemoveAll, preserving them during an empty purge, concurrent initialization, and independent returned AUM values. The temporary-file test now exercises the initial scan, and the shared Chonk tests continue to exercise purge after index construction.

Fixes #20735

Related to #17566