LOO is O(file_bytes) per node; a few large/generated files (lockfiles,
bundled assets) dominate runtime. Add a byte cap (default 32KB, CLI
--max-loo-file-bytes, YAML max_loo_file_bytes, nil disables) — files over
the cap get no refactoring nodes but still flow into the codebase
aggregate and grade. Telemetry-measured: assets sample 42.5s -> 25.8s.

The cap was being filtered out in Analyzer.do_analyze_codebase's
Keyword.take before reaching BlockImpactAnalyzer; added it to the take
list and a regression test at the analyze_codebase layer.

Also lands multi-path args: `health-report <path> [subpath ...]` restricts
the walk to given subpaths (e.g. `. lib test` skips priv/assets/config)
while git context stays anchored at <path>.

At ~3000 nodes the node pool drove peak memory to ~54GB and a hard
slowdown cliff (240 files: 103s). Two causes, both fixed:

1. Each work unit carried its file's full node_ctx (content, tokens,
   cosines). Dispatching a unit to a worker copies the message, so the
   node_ctx was copied once PER NODE. Units now carry only the file key;
   the node_ctx lives in a per-file map captured once per Flow stage —
   O(stages) copies instead of O(nodes). Dropped the unused root_tokens
   from node_ctx while here.

2. The incremental aggregate and project languages were rebuilt per file
   over all file_results — O(files^2). Built once now and shared.

Phase B switched from Task.async_stream to Flow.from_enumerable with
max_demand, bounding in-flight units per stage (backpressure).

Telemetry-measured at 240 files: 54GB -> 10.8GB peak, 103s -> 17s (6.1x).
Output stays bit-identical (parallel == serial guard).

Phase B flat-mapped all prep units into one list before handing it to
Flow, materializing the entire unit set (~3000 maps at 240 files) up
front. Switched to Stream.flat_map so units are pulled lazily under
Flow's max_demand backpressure.

Telemetry-measured at 240 files: peak memory 10.8GB -> 7.1GB. Output
stays bit-identical (parallel == serial guard).