fix(map): wire num_dovetail_fragments (was always 0)

Rust drops dovetailed concordant pairs in join_reads_and_filter (default
no-dovetail policy), matching C++, but never reported the count: the mapper's
dovetail check only inspected *surviving* PairedEndPaired joints, which are never
dovetailed (pairing already filtered them), so num_dovetail_fragments stayed 0
while C++ reported the diagnostic.

Set a thread-local when join_reads_and_filter rejects an otherwise-valid
(opposite-strand, in-range fragment length) pair solely for dovetailing, and
count the fragment when that happened AND no concordant pair survived for any
target — i.e. its only concordant pairing was a dovetail (salmon's definition).
Reporting only; no change to mapping behavior (mapped rate identical). On
SRR1039508 (3M subset) Rust now reports 15,164 dovetail fragments (C++ 22,765;
same order, differing by the tools' internal dovetail accounting + seeding).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B7JMur5DmDpECddErpi2JS

Author: rob-p

crates/salmon-map/src/mapper.rs

@@ -193,23 +193,23 @@ pub fn map_read_pair<'idx, R: RefProvider>(
     let joints = join_reads_and_filter(left, right, &cfg.pair);
 
     let had_candidates = !joints.is_empty();
+    // Count this fragment toward num_dovetail_fragments when an otherwise-valid
+    // concordant pair was rejected only because the mates dovetail AND no
+    // concordant pair survived for any target — i.e. its only concordant pairing
+    // was a dovetail (salmon's diagnostic). The pair is dropped regardless; this
+    // just reports it. (Pairing already filtered dovetails, so the surviving
+    // PairedEndPaired joints below are never themselves dovetailed.)
+    let has_concordant_pair = joints
+        .iter()
+        .any(|j| matches!(j.status, MateStatus::PairedEndPaired));
+    let dovetail = crate::pair::dovetail_rejected() && !has_concordant_pair;
     let mut below = 0u32;
-    let mut dovetail = false;
     let mut raw = Vec::new();
     for j in joints {
         match j.status {
             MateStatus::PairedEndPaired => {
                 let l = j.left.as_ref().unwrap();
                 let r = j.right.as_ref().unwrap();
-                // Dovetail: opposite-strand mates where the downstream (reverse)
-                // mate actually starts upstream of the forward mate — they extend
-                // past each other's start (salmon's `num_dovetail_fragments`).
-                if l.is_fw != r.is_fw {
-                    let (fw, rc) = if l.is_fw { (l, r) } else { (r, l) };
-                    if rc.chain.ref_start() < fw.chain.ref_start() {
-                        dovetail = true;
-                    }
-                }
                 let refseq = refs.ref_seq(j.tid);
                 let al = align_chain(r1, refseq, &l.chain, &cfg.align);
                 let ar = align_chain(r2, refseq, &r.chain, &cfg.align);

crates/salmon-map/src/pair.rs

@@ -161,6 +161,23 @@ thread_local! {
     /// per-read `AHashMap<u32, Vec<usize>>` of the old `group_by_tid` are gone.
     static PAIRED_TIDS: std::cell::RefCell<AHashSet<u32>> =
         std::cell::RefCell::new(AHashSet::new());
+
+    /// Set by [`join_reads_and_filter`] when it rejects an otherwise-valid
+    /// (opposite-strand, in-range fragment length) concordant pair *solely*
+    /// because the mates dovetail, under the default no-dovetail policy. Cleared
+    /// at the start of every call and read once per fragment by the mapper, which
+    /// — combined with "no concordant pair survived" — counts the fragment toward
+    /// `num_dovetail_fragments` (salmon's diagnostic for fragments whose only
+    /// concordant pairing was a dovetail). The pairs are dropped either way; this
+    /// only wires up the count, which previously stayed 0 because the mapper only
+    /// inspected surviving pairs (never dovetailed after filtering).
+    static DOVETAIL_REJECTED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+/// Whether the most recent [`join_reads_and_filter`] rejected an otherwise-valid
+/// concordant pair as a dovetail (see [`DOVETAIL_REJECTED`]).
+pub fn dovetail_rejected() -> bool {
+    DOVETAIL_REJECTED.with(|c| c.get())
 }
 
 /// Upper bound on concordant pairs emitted per target when several repeat loci
@@ -201,6 +218,7 @@ pub fn join_reads_and_filter(
     left.sort_unstable_by_key(|c| c.tid);
     right.sort_unstable_by_key(|c| c.tid);
 
+    DOVETAIL_REJECTED.with(|c| c.set(false));
     let mut joints = Vec::new();
     PAIRED_TIDS.with(|cell| {
         let paired = &mut *cell.borrow_mut();
@@ -248,6 +266,9 @@ pub fn join_reads_and_filter(
                         continue;
                     }
                     if !cfg.allow_dovetail && is_dovetailed(l, r) {
+                        // An otherwise-valid concordant pair, dropped only because
+                        // the mates dovetail — flag it for the num_dovetail count.
+                        DOVETAIL_REJECTED.with(|c| c.set(true));
                         continue;
                     }
                     let cov = l.chain.covered_read_bases() + r.chain.covered_read_bases();