Link the ordinary tests once, and keep their debug info to line tables

Eleven `tests/*.rs` were eleven binaries, each linking the whole graph --
`wgpu` and all -- to run a handful of cases. They are modules of one target
now, under `tests/cases/`, and `cargo test --test suite layout::` still picks
one out. The fuzzers and the `*_cost` measurements stay their own targets:
they are run on their own and want to be selectable without building the
rest.

`profile.test` takes `debug = "line-tables-only"`, which is what a backtrace
here actually reads; the type and variable information was the bulk of what
the linker was writing.

Measured on this machine, rebuilding `iris`'s test targets after a change to
the crate: 14.3 s before, 9.8 s with one target, 7.7 s with both. `target/`
went from 45 GB to 13 GB. The suite still passes 102 tests, and the binary
still carries `.debug_line`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/cases/determinism.rs

@@ -0,0 +1,101 @@
+//! A measurement that decides control flow.
+//!
+//! Comparing boxes catches a widget that moved. It does not catch a widget
+//! that measured a child, believed a different answer from the one a cold
+//! start would give, and took the other branch -- which is the same defect
+//! arriving somewhere it cannot be ignored. A widget here branches on what it
+//! measured, so a disagreement shows up as a different tree.
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+/// Measures `probe` across `axis` and draws one of two children on the
+/// answer. Its own configuration never changes, so which child is drawn is a
+/// property of the layout alone.
+struct BranchesOnMeasurement {
+    probe: StrongWidget,
+    wide: StrongWidget,
+    narrow: StrongWidget,
+    threshold: f32,
+}
+
+impl Widget for BranchesOnMeasurement {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        let mut top = UiRegion::FULL;
+        top.y.end = top.y.start.offset(Px::from_int(40));
+        let measured = painter.widget_within(&self.probe, top).len(Axis::X);
+        let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
+
+        let mut below = UiRegion::FULL;
+        below.y.start = below.y.start.offset(Px::from_int(40));
+        match px > Px::from_f32(self.threshold) {
+            true => painter.widget_within(&self.wide, below),
+            false => painter.widget_within(&self.narrow, below),
+        };
+        Size::LEFTOVER
+    }
+}
+
+fn plant(h: &mut Harness, threshold: f32) -> (WidgetId, WidgetId) {
+    let words = "the quick brown fox jumps over the lazy dog and keeps running";
+    let probe = wtext(words).size(16).wrap(true).add(&mut h.rsc);
+    let wide = rect(Color::RED).add(&mut h.rsc);
+    let narrow = rect(Color::BLUE).add(&mut h.rsc);
+    let branch = BranchesOnMeasurement {
+        probe: probe.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold,
+    }
+    .add(&mut h.rsc);
+    let side = rect(Color::GREEN).width(120).add(&mut h.rsc);
+    h.set_root((side, branch).span(Dir::RIGHT));
+    (wide.id(), narrow.id())
+}
+
+/// Which of the two branches drew, as a pair a test can compare.
+fn taken(h: &Harness, wide: WidgetId, narrow: WidgetId) -> (bool, bool) {
+    (h.region(&wide).is_some(), h.region(&narrow).is_some())
+}
+
+#[test]
+fn a_branch_taken_on_a_measurement_holds_across_repaints() {
+    for threshold in [0.0, 200.0, 400.0, 600.0, 779.0, 780.0, 781.0, 2000.0] {
+        let mut h = Harness::new((900, 600));
+        let (wide, narrow) = plant(&mut h, threshold);
+        let first = taken(&h, wide, narrow);
+        assert_ne!(first, (false, false), "threshold {threshold}: neither drew");
+
+        for frame in 0..4 {
+            h.rsc.widgets_mut().get_dyn_mut(wide);
+            h.rsc.widgets_mut().get_dyn_mut(narrow);
+            h.frame();
+            assert_eq!(
+                taken(&h, wide, narrow),
+                first,
+                "threshold {threshold}, repaint {frame}: the branch moved when nothing did"
+            );
+        }
+    }
+}
+
+#[test]
+fn a_branch_taken_on_a_measurement_is_the_one_a_cold_start_takes() {
+    for threshold in [0.0, 200.0, 400.0, 600.0, 779.0, 780.0, 781.0, 2000.0] {
+        let mut warm = Harness::new((900, 600));
+        let (wide, narrow) = plant(&mut warm, threshold);
+        warm.resize((640, 480));
+        warm.frame();
+        warm.rsc.widgets_mut().get_dyn_mut(wide);
+        warm.frame();
+
+        let mut cold = Harness::new((640, 480));
+        let (cwide, cnarrow) = plant(&mut cold, threshold);
+
+        assert_eq!(
+            taken(&warm, wide, narrow),
+            taken(&cold, cwide, cnarrow),
+            "threshold {threshold}: warm and cold took different branches"
+        );
+    }
+}