Identify compile-poisoning mutants from a failed metamutant compile.

Every mutated branch lives in the one build, so a single mutation that won't compile would sink 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, …). Rather than abort, the runner asks this module which mutant ids the compile error points at, 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 (see Manifest.ids_at_line/2). Only error diagnostics are scanned, never warnings: a failed compile prints every warning the mutations provoke (each footered with the same file:line shape), 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 actually lives — 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 blames the macro-call line no manifest region covers — the runner falls back to macro_poison/2, which attributes by the macro name the compiler blamed (via Mutare.Manifest.ids_in_named_calls/2) instead of by line. Only when both fail does the run abort.