Identify compile-poisoning mutants from a failed metamutant compile.

Every mutated branch is included in one build, so a single mutation that won't compile would prevent the whole run. Built-in mutators are compile-safe by construction, but a custom mutator can emit something that doesn't (an unbound variable, an undefined local call, …). The runner uses this module to identify the mutant ids at the error location, then drops them and rebuilds.

We map each error's file:line to the mutant id(s) whose generated code spans that line, via a Mutare.Manifest built on demand from the file's rendered metamutant and the dispatch variable its generated code reads (Mutare.Schema's :metamutants and :dispatch_vars; see Manifest.ids_at_line/2). Only error diagnostics are scanned, never warnings: compiler output also includes warnings caused by mutations (each with a footer in the same file:line format), and mistaking those for the error's location dropped valid mutants as false poison (see error_locations/1). The manifest records the full line range of every mutant's generated code — its selector clause body, and for a lifted mutant the gated clause (when mutare_active === <id>) where its guard/head-pattern code appears — so a poison is found whether the error points at the clause, a later line of a multiline body, a lifted mutant clause, or (as a coarse fallback) the surrounding case. Matching only the selector clause's start line, as we used to, missed all but the first of those.

The manifest is built here, lazily, only for the file(s) a compile error names — not eagerly for every mutated file during the scan. That eager build was pure waste: a manifest is read only on a failed compile (rare — built-in mutators are compile-safe), yet a full Sourceror.parse_string! of a large metamutant is by far the most expensive step of the scan (a 1500-line source whose metamutant is ~40k lines took minutes to re-parse). Deferring it to the poison path removes that cost from every healthy run.

When line attribution maps nothing — the signature of an inline DSL macro that rejects the spliced selector, where the compiler reports an error on the macro-call line no manifest region covers — the runner falls back to macro_poison/4, which attributes by the macro name in the compiler output (via Mutare.Manifest.ids_in_named_calls/2) instead of by line. Only when both fail does the run abort. The runner obtains both results through attribution/4, which builds each file's manifest once for the round; ids/4 and macro_poison/4 are the two halves on their own.

An error can also land in a clean region's uninstrumented copy (Mutare.Transform.CleanRegion), which belongs to no mutant: the transform copies any source without asking whether it survives the copy (a macro may refuse to expand twice, or under a relocated name). attribution/4 reports those regions under :clean, as {file, range} — the identity the region's own guard carries — and the runner drops them through Mutare.Schema's skip_regions. A macro that raises inside a clean copy is excluded from the macro fallback: there is no selector in a copy for it to have rejected, so its mutants elsewhere in the file are not the cause.

A schema metamutant contains local integer ids. The runner supplies Mutare.RuntimeId.file_index(schema.sites) so attribution translates {file, local_id} to report ids before merging files. Without an index these APIs return the integers read from the metamutant, as used by standalone transforms. The macro fallback retains the call-site file through that conversion; two files' local id 1 must never collapse together. An id absent from the index corresponds to no mutant in this run — a file the selection left with nothing to emit renders pristine, and pristine source can imitate a selector — so it is dropped, degrading to "mapped nothing" rather than crashing a run mid-recovery.