fix(test): the unmapped-reason test re-implemented the logic it was testing

[BenjaminDEMAILLE]

A test that was not testing the shipped code, and the per-read allocation it was hiding.

The test

read_align.rs had this inside the test body:

let classify = |reasons: &[&str]| -> UnmappedReason {
    let filter_reasons: std::collections::HashMap<&str, i32> =
        reasons.iter().map(|k| (*k, 1)).collect();
    let has_mismatch = filter_reasons.contains_key("mismatch_max")
        || filter_reasons.contains_key("mismatch_rate");
    let has_other = filter_reasons
        .keys()
        .any(|k| *k != "mismatch_max" && *k != "mismatch_rate");
    ...
};

It rebuilds the decision rather than calling it. The assertions below it are fine, but they check a copy of the logic that lives in the test, so the test would pass unchanged if the production code were deleted. It is asserting that the test author can write an if.

It now drives FilterReasons, the same counters the aligner uses, so changing that decision fails the test.

What FilterReasons is

Making the test call the real thing meant giving the real thing a name. The filter loop kept its counts in a HashMap<&str, i32> built per read and incremented per filtered transcript: a heap allocation on every read and a string hash on every increment, for something whose only consumers are two debug logs and one boolean decision.

It is now a [u32; 9] indexed by constant. The consumers ask only whether a count is non-zero, so nothing here can reach the output except through the unmapped_reason decision, which is unchanged and now under test. Debug prints the non-zero reasons in a fixed order, which reads better than the map's arbitrary one.

SpliceJunctionDb moves to FxHashMap in the same spirit — it is queried per candidate junction while stitching, and cluster_seeds already made this choice for its integer-keyed maps. Only get and insert are ever called on it and it is never iterated, so the hasher cannot reach the output.

Performance: no

Neither change is measurable end to end, and I would rather say so than dress this up as a perf PR. Six interleaved rounds on 2M reads at 16 threads:

	median
before	20.70 s
after	20.48 s

Direction mixed across the six, inside the run-to-run spread, and the machine sat at 72-85% idle rather than the 88% the bench script gates on. Call it unmeasured.

They are here because the test was not testing anything and because both changes remove work that has no reason to exist, not because of a number.

For scale on why one allocation per read is not measurable: the align path does about 1 000 heap allocations per read (measured in #168). This removes one of them.

Verification

Output-neutral: SAM byte-identical on 200 000 real reads (ERR12389696, yeast) against the parent commit, whole file including header.

Gate: 561 lib + 26 integration tests, cargo clippy --all-targets -- -D warnings, cargo fmt --check, all green.