Decide layout on the grid end to end, and delete the tolerance

`Px` and `PxVec2` reach the last places a pixel was a float: the window, the
box a widget reads, the box it is compared against, and `PixelRegion`. A
pointer, a wheel notch and a shaped glyph advance still arrive as floats,
and each is put on the grid where it arrives.

`Holds` is an interval of `Px`. `HOLDS_EPSILON_PX` is gone with the
`exact`/tolerant split it existed for: `at` is the length a widget read, an
open end is the next step along, and `same_px` is equality. `Span`'s margin
from `5ed9e87` goes too -- the box a parent hands back and the sum of what
its children asked for are counts of the same step, so the boundary decides
the same way from either side.

Three things had to be true for that, and were not:

`Holds::through` inverts `px + rel * box`, which rounds -- so a part of a
given length came from a range of boxes, and inverting the length alone gave
a point that need not contain the box the part was drawn in. It now maps the
half step either side, and one more for a length composed down the chain
against the same length measured against the window.

`RegionRemap` translates when a box only moved, rather than dividing to find
each part's fraction and multiplying to place it again. Two roundings landed
a step from where growing the tree that way does; a move is exact on a grid,
which is the whole reason `tests/drift.rs` was written.

A pixel is `1/1024` rather than `1/64`. At `1/64` the residue of a length
reached two ways was one step, and one step was 0.016 px -- enough to move
a box. `PX_SHIFT` and `REL_SHIFT` are the only statement of the grid now,
and the shader's copy is prepended from them rather than written twice.

Checked: fmt, clippy, 102 tests, 100 generated seeds in 75 s, all five
shrinker cases at 300 seeds, and `tabs`, `view`, `minimal`, `text` and
`random` byte-identical at 1920x1200.

What the fuzzers ask for is now a step, not a twentieth of a pixel: the
shrinker's five cases agree within one (`resize` exactly), and the oracle's
two-operation cases within two. The residue is a single rounding either way
-- it scales with the grid rather than accumulating, which is why it is a
thousandth of a pixel now. Closing it means one way of asking how long a box
is, rather than a chain composed down and a length measured against the
window; that is a bigger change than this one.

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

src/widget/position/span.rs

@@ -52,40 +52,39 @@ impl Widget for Span {
         );
 
         // Whether anything is left over is a question in pixels: `rel(0.5)`
-        // beside 300 px is full at 600 and overfull at 400. The room to divide
-        // is `len * fixed - total.px`, and under `HOLDS_EPSILON_PX` of it is
-        // none -- because the length where the room runs out is exactly the
-        // box a parent sizing itself from this answer hands back, and that box
-        // returns through the chain a few bits either way. Without the margin
-        // 0.00003 px of rounding decides whether a leftover-only child is
-        // drawn at all. The validity range is split at the moved boundary, and
-        // exact there, since no box lands on it any more.
+        // beside 300 px is full at 600 and overfull at 400. The room to
+        // divide is `len * fixed - total.px`, and the length where it runs
+        // out is exactly the box a parent sizing itself from this answer
+        // hands back -- which is why this used to need a margin either side
+        // of the boundary, and why it does not now: that box and this sum are
+        // whole counts of the same step, and both routes to it land on the
+        // same count. What the generated oracle checks is the consequence,
+        // since which children exist at all turns on this.
         let fixed = Rel::ONE - total.rel;
-        let margin = Px::from_f32(HOLDS_EPSILON_PX);
         let mut shares = false;
         if total.leftover > Weight::ZERO {
-            let current = Px::from_f32(painter.px_len(axis));
+            let current = painter.px_len(axis);
             let holds = if fixed > Rel::ZERO {
-                // The box length at which the room reaches the margin.
-                let enough = (total.px + margin).div(fixed);
-                shares = current > enough;
+                // The box length the fixed parts alone fill.
+                let full = total.px.div(fixed);
+                shares = current > full;
                 match shares {
-                    true => Holds::exact(enough.to_f32().next_up()..=f32::INFINITY),
-                    false => Holds::exact(f32::NEG_INFINITY..=enough.to_f32()),
+                    true => Holds::from(full.next_up()..=Px::MAX),
+                    false => Holds::from(Px::MIN..=full),
                 }
             } else if fixed < Rel::ZERO {
                 // The relative parts grow faster than the box does, so here
                 // a shorter box is the one that leaves room.
-                let enough = (total.px + margin).div(fixed);
-                shares = current < enough;
+                let full = total.px.div(fixed);
+                shares = current < full;
                 match shares {
-                    true => Holds::exact(f32::NEG_INFINITY..=enough.to_f32().next_down()),
-                    false => Holds::exact(enough.to_f32()..=f32::INFINITY),
+                    true => Holds::from(Px::MIN..=full.next_down()),
+                    false => Holds::from(full..=Px::MAX),
                 }
             } else {
                 // The relative parts take exactly the box, whatever it is, so
                 // the only room is what negative pixels leave.
-                shares = total.px < margin.neg();
+                shares = total.px < Px::ZERO;
                 Holds::ANY
             };
             painter.holds(axis, holds);