Port the enemy footprint decision-boundary probe to Rust (#227) (#353)

Port-first entry 2. `test/enemyBaseField.spec.ts` carries two claims, not one,
and only the first has a Rust counterpart. `worstAbs`/`worstRel` grade the
field's values, and `fixtures.rs` already reproduces those at both seeds in
three magnitude buckets. The second claim is `footprintDisagreements`: port and
game never fall on opposite sides of a cut at 0.05 through
`min(v, ENEMY_PLACEMENT_CAP)`. Nothing in Rust graded that.

The gap is real rather than theoretical, because the two checks cannot see each
other. An aggregate tolerance passes a residual that still moves a position
across the cut, and a cut is what the overlay does with this field. The nearest
Rust check, `the_enemy_fixture_is_mostly_basement_...`, compares positive
counts, so two positions could swap sides and the count would not move.

Planted rather than predicted:

| plant | result |
| --- | --- |
| bias the port by 0.011 | `a value sits 8.04e-4 from the cut` |
| bias the port by 0.03 | `port and game fall on opposite sides` - 3 at seed 123456 |

The second is the one that matters: 0.03 is 33x below the deleted spec's own
`ABS_TOL` of 1.0, so the aggregate arms would have passed it.

Two guards beside the probe, because a zero on its own can be luck. The count
of positions inside the cut is frozen per seed - 39 of 1032 at seed 123456, 37
at seed 777771 - so a port returning a constant cannot satisfy it. And the
nearest value to the cut is required to stay above 1e-3, so the f32 read cannot
be what decides a side.

This unblocks deleting `test/enemyBaseField.spec.ts`, which imports
`src/noise/enemies/enemyBaseField.ts` and therefore cannot outlive the #227
deletion. The spec stays until then; the coverage is now in both places.

Claude-Session: https://claude.ai/code/session_01UVcbv1pAhPUoCC6aBwZUtg

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: wormeyman

crates/fmw-noise/src/fixtures.rs

@@ -6068,6 +6068,7 @@ use crate::enemies::catalog::{
     ENEMY_PLACEMENT_CAP,
 };
 use crate::enemies::field::{EnemyBaseField, EnemyFieldParams};
+use crate::eval::math::min2;
 
 #[test]
 fn reproduces_the_games_enemy_base_field_at_both_seeds() {
@@ -6202,6 +6203,78 @@ fn the_enemy_fixture_is_mostly_basement_so_the_probability_would_grade_nothing()
     }
 }
 
+#[test]
+fn the_port_and_the_game_never_straddle_the_footprint_cut() {
+    // The half of `test/enemyBaseField.spec.ts` that `worstAbs`/`worstRel` could
+    // not see, ported here for #227 before that spec goes with
+    // `src/noise/enemies/enemyBaseField.ts`.
+    //
+    // Both of those are aggregates. A residual small enough to pass them can
+    // still put the port on the far side of a cut from the game, and a cut is
+    // what the overlay actually does with this field. `PROBE_CUT` was
+    // `ENEMY_FOOTPRINT_THRESHOLD` until the overlay moved from thresholding the
+    // probability field to rolling against it, so it is a decision-boundary
+    // probe rather than a live threshold - the value it takes matters less than
+    // that some cut through the live part of the range is graded at all.
+    const PROBE_CUT: f64 = 0.05;
+    let in_footprint = |v: f64| min2(v, ENEMY_PLACEMENT_CAP) >= PROBE_CUT;
+
+    let fixture = load_captured_at("test/fixtures/oracle-enemy-base.seed123456.json", "2.1.11");
+    let positions = fixture_positions(&fixture, "positions");
+
+    // (seed, positions inside the cut). Measured, not chosen.
+    let expected: [(u32, usize); 2] = [(123_456, 39), (777_771, 37)];
+    for (case, &(seed, want_inside)) in fixture.get("cases").as_array().iter().zip(expected.iter())
+    {
+        assert_eq!(case.get("seed").as_f64() as u32, seed, "case order");
+        let field = EnemyBaseField::new(&EnemyFieldParams::defaults(seed));
+        let values = case.get("values").as_array();
+
+        let mut disagreements = 0usize;
+        let mut inside = 0usize;
+        let mut margin = f64::INFINITY;
+        for (i, (x, y)) in positions.iter().enumerate() {
+            let want = values[i].as_f64();
+            let port = f64::from(field.field(snap_coord(*x), snap_coord(*y)) as f32);
+            if in_footprint(port) != in_footprint(want) {
+                disagreements += 1;
+            }
+            if in_footprint(want) {
+                inside += 1;
+            }
+            margin = margin
+                .min((min2(want, ENEMY_PLACEMENT_CAP) - PROBE_CUT).abs())
+                .min((min2(port, ENEMY_PLACEMENT_CAP) - PROBE_CUT).abs());
+        }
+
+        assert_eq!(
+            disagreements, 0,
+            "seed {seed}: port and game fall on opposite sides of the cut"
+        );
+
+        // Anti-vacuity, and it is the reason this is not a one-liner: the cut
+        // has to actually separate this fixture. A port that returned a
+        // constant would satisfy the line above on its own.
+        assert_eq!(
+            inside,
+            want_inside,
+            "seed {seed}: positions inside the cut, of {}",
+            positions.len()
+        );
+        assert!(
+            inside > 0 && inside < positions.len(),
+            "seed {seed}: the cut does not separate"
+        );
+
+        // And no value sits near the cut, so the f32 read above cannot be what
+        // decides a side. Without this the zero above could be luck.
+        assert!(
+            margin > 1e-3,
+            "seed {seed}: a value sits {margin:e} from the cut - rounding could flip it"
+        );
+    }
+}
+
 #[test]
 fn every_enemy_distance_scalar_saturates_at_2400_tiles() {
     // `enemy_intensity` clamps its distance at 2400, so the radius, quantity,