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>

core/src/ui/painter.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, Holds, Len, Px, RegionAlign, Rel, RenderedText, Size, StrongWidget, TextAttrs,
+    Axis, Holds, Len, Px, PxVec2, RegionAlign, Rel, RenderedText, Size, StrongWidget, TextAttrs,
     TextBuffer, TextData, TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Weight,
     WidgetId, Widgets,
     render::{
@@ -9,7 +9,6 @@ use crate::{
         PrimitiveKind, TexturePrimitive,
     },
     ui::render_state::DrawInfo,
-    util::Vec2,
 };
 const AXES: [Axis; 2] = [Axis::X, Axis::Y];
 
@@ -28,7 +27,7 @@ pub struct Painter<'a> {
     /// is the one recorded as its offer.
     pub(super) offered: Vec<WidgetId>,
     /// The box this widget was first asked about in, in pixels.
-    pub(super) offered_px: Vec2,
+    pub(super) offered_px: PxVec2,
     /// Whether this draw is in that box, which makes the questions it asks
     /// the ones a cold layout asks and their answers the ones to keep.
     pub(super) at_offer: bool,
@@ -291,11 +290,11 @@ impl<'a> Painter<'a> {
     }
 
     /// The pixel size of a part of the box this widget was asked in.
-    fn px_within_offer(&self, local: UiRegion) -> Vec2 {
+    fn px_within_offer(&self, local: UiRegion) -> PxVec2 {
         let size = local.size();
-        Vec2::new(
-            size.x.to_px(Px::from_f32(self.offered_px.x)).to_f32(),
-            size.y.to_px(Px::from_f32(self.offered_px.y)).to_f32(),
+        PxVec2::new(
+            size.x.to_px(self.offered_px.x),
+            size.y.to_px(self.offered_px.y),
         )
     }
 
@@ -363,7 +362,7 @@ impl<'a> Painter<'a> {
 
     /// This widget's box in pixels. Reading it makes the drawing one that
     /// holds for this box only, until `holds` says how far it goes.
-    pub fn px_size(&mut self) -> Vec2 {
+    pub fn px_size(&mut self) -> PxVec2 {
         let px = self.state.px_of(self.move_idx, self.region);
         for (own, len) in self.own.iter_mut().zip([px.x, px.y]) {
             if *own == Holds::ANY {
@@ -375,7 +374,7 @@ impl<'a> Painter<'a> {
 
     /// One axis of this widget's box in pixels. Prefer this to
     /// [`Self::px_size`] when the other axis cannot affect the drawing.
-    pub fn px_len(&mut self, axis: Axis) -> f32 {
+    pub fn px_len(&mut self, axis: Axis) -> Px {
         let len = self.state.px_of(self.move_idx, self.region).axis(axis);
         let own = &mut self.own[axis as usize];
         if *own == Holds::ANY {