Say the environment once, and stop a hint read going uncounted

The eleventh sweep, over the built-in bounds work in 2ac0843.

`Painter::size_hint` refused to answer for a bounded widget by returning
above the diagnostics, so that read was neither a hint hit nor a miss and
`hint_read` recorded nothing. It is a miss now, with the reason on it.

The two `for axis in Axis::BOTH` loops that `draw_widget` grew, both
writing `own_holds`, are one loop, and the comment about combining the
ask's holds no longer sits between a comment and the code it describes.

`Declared::from_axes` lost its only caller with `Widgets::declared_lens`;
`Bounds::from_axes` and `SizeRule::declared` never had one.

The scenario shrinker printed a rule with derived `Debug`, which is 130
characters an axis in a line that carries every ancestor, in the one
function whose job is output a tree can be rebuilt from. It prints its
parts again.

`bounds_cost` invented three environment-reading spellings where four
copies of one `env` helper already existed; there is now one, in
`tests/rig`, and the four copies are gone. It also verified 128 regions
inside its measured loop, which the other rigs deliberately do before
theirs; that measured 0.65% of the total, and none of it is layout.

The 250-window row with a 300 cap was built by two tests, and the one
that still explained itself tested less; they are one. The half of
`a_cap_attribute_narrows_the_widgets_box` that the wrapper's removal left
without its deciding assertion is the allocator's path instead, which
nothing at the root covered.

Format, workspace clippy under -D warnings with and without
layout-diagnostics, 206 ordinary and 210 diagnostic tests, 400 depth-5
trees warm against cold in 64.19s, and the cold dump byte-identical to
2ac0843 across all 34,986 boxes.

tests/bounds_cost.rs

@@ -1,17 +1,33 @@
-//! CPU comparison of bounds attributes and the former wrapper, using the
-//! same builder calls and geometry. Run the release executable under perf;
-//! process totals include the cold frame. MODE=plain|exact|cap, REDRAW=0|1.
+//! CPU comparison of a bounds attribute against the `MaxSize` wrapper it
+//! replaced, using the same builder calls and the same geometry. The wrapper
+//! is gone from this tree, so its side of the comparison is run by checking
+//! out a commit that still has it: the fixture is written to build the same
+//! way at both.
+//!
+//!     MODE=cap FRAMES=2000 cargo test --release --test bounds_cost \
+//!       -- --ignored --nocapture
+//!
+//! `MODE` is `plain`, `exact` or `cap`; `REDRAW=1` marks every widget for
+//! redraw each frame; `FRAMES` is how many resize frames to measure. Use
+//! repeated `perf stat -e instructions:u` runs on the executable directly.
+//! Process totals include the cold frame, so compare identical modes and
+//! frame counts. Wall time on this machine is not a stable comparison.
+
+mod rig;
+
 use iris::{harness::Harness, prelude::*};
+use rig::env;
+
+/// The two widths the loop alternates. The cap of 80 binds at 300 and does
+/// not at 100, so the measured frames cross it in both directions.
+const WIDTHS: [i32; 2] = [100, 300];
 
 #[test]
 #[ignore = "instruction-count measurement"]
 fn bounds_cost() {
-    let mode = std::env::var("MODE").unwrap_or_else(|_| "cap".into());
-    let redraw = std::env::var("REDRAW").is_ok_and(|value| value == "1");
-    let frames = std::env::var("FRAMES")
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(2000);
+    let mode = env("MODE", "cap".to_string());
+    let redraw = env("REDRAW", 0_u8) != 0;
+    let frames = env("FRAMES", 2000_usize);
     let mut h = Harness::new((300, 512));
     let mut column = Span::empty(Dir::DOWN);
     let mut leaves = Vec::new();
@@ -38,23 +54,35 @@ fn bounds_cost() {
         ids.len(),
         std::mem::size_of::<SizeRule>()
     );
-    for frame in 0..frames {
-        if redraw {
-            for &id in &ids {
-                h.rsc.widgets_mut().mark_for_redraw(id);
-            }
-        }
-        let width = if frame % 2 == 0 { 100 } else { 300 };
+    // That the fixture measures what it says is checked on both sides of the
+    // crossing here rather than inside the measured loop, which is what the
+    // other rigs do. Per frame it measured only 0.65% of the total (5.780B
+    // against 5.743B instructions at MODE=cap, FRAMES=2000), but none of it
+    // is the layout the number is about.
+    for width in WIDTHS {
         h.resize((width, 512));
         h.frame();
         let expected = match mode.as_str() {
             "plain" => width / 2,
             "exact" => 40,
             "cap" => (width / 2).min(80),
-            _ => unreachable!(),
+            _ => unreachable!("the mode was checked while building"),
         };
         for id in &leaves {
             assert_eq!(h.region(id).unwrap().size().x, Px::from_int(expected));
         }
+        println!(
+            "width {width}: first leaf {}",
+            h.region(&leaves[0]).unwrap()
+        );
+    }
+    for frame in 0..frames {
+        if redraw {
+            for &id in &ids {
+                h.rsc.widgets_mut().mark_for_redraw(id);
+            }
+        }
+        h.resize((WIDTHS[frame % WIDTHS.len()], 512));
+        h.frame();
     }
 }