Take two roundings out of where a box comes from

Traced what was left of the warm-against-cold difference after fixed point.
It is not accumulation and not one place: it is the same box reached two
ways, and each way rounds where the other does not.

`Scroll` was writing a box it had been given back out as its own length in
pixels. That is the same box in another form, and centring a part in `rel 1`
lands a step from centring it in `px 900`, because halving a difference is
not halving each part of it. Content that fills the viewport and has not been
scrolled is now handed back as it came, which makes the shrinker's `repaint`
and `resize-repaint` cases agree exactly rather than within a step.

`Span` placed each child a step from where the last one ended, so the
rounding of every share was carried along the row. A position is now the
fixed parts before it -- a sum, exact -- plus one rounded share of the room.
Measured: two hundred equal shares of a 1000 px row ended at 999.999 and now
end at 1000, and `tests/cases/layout.rs` pins it at 2, 3, 7, 64 and 200.

What is left is a step per level of nesting between the two ways, which is
what the fuzzers now allow: four of the five shrinker cases pass at one step
and the fifth is five spans deep. Closing it needs one way of asking where a
box is, which is a bigger change than this.

Checked: fmt, clippy, 103 tests, all five shrinker cases at 300 seeds, 100
generated seeds, five examples byte-identical at 1920x1200.

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

tests/generated.rs

@@ -31,12 +31,11 @@ fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
 }
 const SEEDS: [u64; 9] = [1, 2, 3, 5, 8, 10, 13, 86, 98];
 
-/// The same box, to a step of the grid per operation. Warm and cold reach a
-/// coordinate by different arithmetic: a move lands on the same number now,
-/// and a length composed one way against the same length measured another can
-/// land one step out. These cases apply two operations in turn, so they allow
-/// two steps -- a thousandth of a pixel each, where this was a twentieth of
-/// one before any of it was on a grid.
+/// The same box, to a step of the grid per level of nesting between the two
+/// ways of reaching it. A move, a repaint and a row of shares land on the
+/// same number now; what is left is a box centred in a fraction of its parent
+/// against the same box centred in its own pixels. A step is a thousandth of
+/// a pixel, where this was a twentieth of one before any of it was on a grid.
 const AGREE_STEPS: i32 = 2;
 
 fn same_region(got: Option<PixelRegion>, want: Option<PixelRegion>) -> bool {