memory: charge the refresh's retained parse pool and the no-owner build residue

[ScriptedAlchemy]

Summary

Follow-up to #2490 / #2525 after the idle-thread release, parser-stack drop and graph owner heaps. With both graph owners resident, a settled daemon's uncharged anonymous memory now levels off at about 300 MB. Two things are still uncharged and grow with the corpus or the refresh, so a fixed runtime allowance and the #2490 invariant test cannot be added yet.

Evidence

Release production build, isolated HOME/TRACEDECAY_DATA_DIR, systemd-run --user --scope -p MemoryMax=6G -p MemorySwapMax=1G, 96-core host. Gap = anon + swap - charged owners.

1. The refresh increment's retained parse pool and build residue. SharedRetainedParsePool keeps trees, extraction artifacts and sources for every document an increment re-extracted (up to 256 docs / 64 MiB of source). No owner charges them.

corpus	cold gap	gap after a 40-file refresh commit
every 20th tracked file (293 files)	212,824,510	279,094,351
every 5th tracked file (1,164 files)	266,709,683	318,949,300
synthetic, 300 Rust files x 160 fns	178,809,782	375,914,470

The retained tree bytes have no live measure. tree-sitter allocates through glibc malloc. One way forward: route tree-sitter to mimalloc with ts_set_allocator, build and reparse retained documents inside an OwnerHeapV1 scope, and register the pool as a resident owner charged by its heap pages. Another: stop retaining across builds, measuring the reuse rate first.

2. The no-owner residual. With both graph owners idle-released, what stays resident:

corpus	anon + swap, no owners	[anon:mimalloc]	glibc / unnamed anon
293 files	227,074,048	165.6 MB	51.5 MB
1,164 files	294,797,312	205.3 MB	78.0 MB
full clone (5,855), after a refresh	435,204,096	343.6 MB	76.8 MB

The glibc part levels off (SQLite page caches filling to their per-connection bound). The mimalloc part keeps growing, about 34-45 KB per file. #2661's heaptrack puts non-owner live Rust at about 5 KB per file, so most of this is pages pinned by a few long-lived blocks from index builds and activation. Next step: an allocation-site profile of the no-owner state (heaptrack on a system-allocator build, or an MI_STAT build) to find which long-lived allocations pin build pages. Then either allocate those results after the build scratch is freed, or build them in their own owner heap.

Acceptance

Anon + swap stays within charged owners plus one fixed allowance on a cold index and after a refresh, from 300 to 5,855 files, including a heavy-file corpus. A daemon test then asserts it and fails on today's master.

[ScriptedAlchemy]

Both halves now have fixes merged. Leaving this open: a heavy-file refresh still leaves about 210 MB uncharged, and that memory is allocator retention, not live data with an owner.

Retained parse pool: #2775 (aa1e2d5). Retained documents are parsed, reparsed and copied inside the pool's own mimalloc heap, which became possible once #2773 (c36fa64) moved tree-sitter and SQLite onto mimalloc. The heap's pages are the charge of a new first-shed retained_parses owner, and releasing it returns the heap whole. In a mimalloc test binary, 120 retained 400-function documents were charged 318,376,568 B and releasing them freed 348,381,184 B of RssAnon.

No-owner residue: #2778 (4e3e1d6). A jemalloc heap profile of the 336-file corpus (every 20th tracked file) found two per-file sites alive after the owners' idle release:

• SharedCodeIndexBytePoolV1::intern: 4,997,412 B in 517 blocks.
• The physical artifact pool: 269,394 B in 300 blocks.

Both are weak caches, and a Weak keeps its allocation. For Arc<[u8]> that is the source bytes themselves, so every dropped source stayed allocated until a map-doubling prune. The worker now drops dead entries once each pass lets go of its capture and build.

Shipped-allocator journey (debug production, 6 GiB scope), anon+swap after the owners' idle release:

corpus	before	after
336 files	179,424 kB	167,080 kB
1,345 files		177,908 kB

That is now about 11 KB per extra file, against the 34–45 KB per file measured above.

What remains (heavy files, refresh). 300 Rust files × 160 functions, with every file edited in the refresh. Gap = anon+swap − charged owners:

• Cold: 156,352,862 B.
• After the refresh: 366,002,592 B, with retained_parses charged 660,569,696 B.

A jemalloc profile of the post-refresh state has 247 MB live. It is the retained parse pool's artifacts and sources plus the fixed catalogs; no other per-file site. The extra ~210 MB is retained free memory from the refresh's parent decode and build scratch. The next step is to measure whether the refresh's workers return it (collect/purge after the increment) rather than to attribute live blocks.