fix(ogit_bridge): drop is_ancestor MAX_VISITS cap + rustfmt collapse (codex P2)

Two CI fixes on PR #193:

1) Codex P2 — Drop the MAX_VISITS=4096 hard cap in `is_ancestor`.
   The previous cap could produce false-negatives on large
   biomedical ontologies (FMA: 75k classes; ChEBI: 200k+ classes)
   where a descendant has more than 4096 reachable superclass
   nodes before the target ancestor is popped.

   Termination is still guaranteed by the `visited: HashSet<&str>`:
   every parent IRI enters at most once, frontier pushes are
   gated on `visited.insert(...)`, so the total work bound is
   O(unique IRIs reachable from descendant) — finite by the
   schema's own finiteness. No explicit cap needed.

2) Rustfmt 1.95.0 collapse on the new
   `make_probability_mask_at_half_is_bernoulli_half` test
   assertion — same canonical-fmt collapse as prior hotfixes.

No behavioral change beyond removing the artificial cap.

Author: claude

src/hpc/dn_tree.rs

@@ -580,10 +580,7 @@ mod tests {
         let mean = total as f64 / N as f64;
         // σ per word = sqrt(64 * 0.5 * 0.5) = 4; mean's SE = 4 / √N = 0.125.
         // Tolerance 2.0 ≈ 16 SEs — comfortable margin against flakes.
-        assert!(
-            (mean - 32.0).abs() < 2.0,
-            "make_probability_mask(0.5) mean popcount {mean:.4} not near 32"
-        );
+        assert!((mean - 32.0).abs() < 2.0, "make_probability_mask(0.5) mean popcount {mean:.4} not near 32");
     }
 
     #[test]

src/hpc/ogit_bridge/schema.rs

@@ -684,24 +684,29 @@ impl OntologySchema {
         // linear chain via `EntityClass.parent` alone — correct for
         // single-inheritance schemas but missed ancestors reachable
         // only through `EntityClass.extra_parents` (OWL multi-inheritance,
-        // common in FMA / ChEBI). MAX_VISITS bounds total work for any
-        // cycle that slipped past upstream antisymmetry checks.
-        const MAX_VISITS: usize = 4096;
+        // common in FMA / ChEBI).
+        //
+        // # Termination
+        //
+        // `visited` is a monotonically-growing `HashSet<&str>` keyed by
+        // IRI; each parent IRI enters the set at most once. Frontier
+        // pushes are gated on `visited.insert(...)`, so every IRI is
+        // pushed at most once across the entire walk. Total work is
+        // therefore O(unique IRIs reachable from descendant) — finite
+        // by the schema's finiteness, regardless of branching factor
+        // or depth. No explicit visit cap is needed; previous codex P2
+        // pointed out that a hard cap would produce false-negatives on
+        // large biomedical ontologies (FMA: 75k classes; ChEBI: 200k+).
         let mut frontier: Vec<&str> = vec![descendant];
         let mut visited: std::collections::HashSet<&str> = std::collections::HashSet::new();
         visited.insert(descendant);
-        let mut visits = 0usize;
         while let Some(current) = frontier.pop() {
-            visits += 1;
-            if visits > MAX_VISITS {
-                return false;
-            }
             let entity = match self.entities.get(current) {
                 Some(e) => e,
-                // Walk hit an unknown IRI mid-chain — that subtree of the
-                // closure terminates here. Continue exploring siblings
-                // rather than aborting, since other parents may yet reach
-                // `ancestor`.
+                // Walk hit an unknown IRI mid-chain — that subtree of
+                // the closure terminates here. Continue exploring
+                // siblings rather than aborting, since other parents
+                // may yet reach `ancestor`.
                 None => continue,
             };
             for parent in entity.parents() {