perf(rpc): per-source-file eviction to bound polyglot RewriteRpc server memory

[jkschneider]

Summary

Bounds the memory of the polyglot RewriteRpc servers (Java/JS/Python/Go/C#), whose object + ref caches previously grew insert-only for the whole process lifetime, and adds the Phase-0 profiling instrumentation to measure it. Two commits:

1. perf(rpc): evict each source file from RPC caches after the recipe stack visits it — the eviction primitive.
2. perf(rpc): emit per-call metrics CSV for the Python and C# RPC servers — profiling parity across all four servers.

Problem

Every RewriteRpc peer keyed visited SourceFiles into localObjects/remoteObjects + ref maps and never self-evicted; only an explicit Reset cleared them. Within a repo, every file stayed resident across every recipe cycle, so peak memory scaled with file count and was only reclaimed when the subprocess was killed per repo.

Fix — per-source-file Evict

RecipeRunCycle iterates source-outer / recipe-inner (editSource runs the whole recipe stack over one file before the next), so the end of editSource (and the scan lambda) is a clean per-file boundary. A new Evict{id} primitive drops that file's tree and rolls each touched peer's ref maps back to a pre-file checkpoint:

• Fire-and-forget JSON-RPC notification (NON_NULL serialization omits the null id, so it is a true notification everywhere); handlers are total, and the Go/Python read loops skip replying to a null-id request so an errored notification can't fail in-flight requests.
• Ref rollback is symmetric/lockstep: dropping the send-side ref forces the next file to re-ADD the interned JavaType (shared across files), so the receiver never sees a dangling REF_USE. Send-side rollback = protocol correctness; receive-side = the memory bound.
• Handlers in all five peers (Java, JS onNotification, Python, Go via ReferenceMap.RollbackTo, C#). Recipe/accumulator/execution-context state is keyed separately and preserved, so a scanning recipe's accumulator survives across files within a cycle.

Eviction is unconditional (no config flag).

Profiling (Phase 0)

• Per-call metrics CSVs now carry local_objects,remote_objects,refs residency columns for all four language servers (Go/JS in commit 1; Python + C# in commit 2), so a run shows the cache-size ramp (evict off) vs sawtooth (evict on). Python's --metrics-csv was previously a no-op stub; C# had no metrics CSV at all. C# records via a message-handler wrapper since StreamJsonRpc dispatches by attribute and has no central loop.
• RewriteRpcProcess gains an opt-in subprocess RSS sampler (REWRITE_RPC_RSS_MS -> rpc-rss-<pid>.csv) that uniformly covers all four languages, including native/off-heap growth the in-process counters miss.

Measured

Same-binary A/B on the Python server (per-repo peak subprocess RSS, evict off -> on): flask 133->94 MB (-30%), poetry 285->86 MB (-70%), scrapy 374->68 MB (-82%). The "before" curve climbs monotonically with file count; "after" is bounded and does not scale with repo size. Cost: ~30% longer wall-clock from the per-file evict notifications.

Testing

Full RewriteRpcTest (19 tests; loopback recipe runs exercise the hook + client rollback + inbound Evict) passes, including a new evictDropsTreeFromBothPeers. The metrics commit is additive and does not touch the Java loopback test path; it is verified to compile via py_compile, dotnet build, and :rewrite-csharp:compileJava.

Follow-up (separate repo)

The Moderne CLI already wires each server's metricsCsv; C# (csharp-rpc.csv) needs a one-line CLI change to pass the path, which lands after this releases.