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/fixed.rs

@@ -1,4 +1,4 @@
-use crate::UiNum;
+use crate::{UiNum, util::Vec2};
 use std::{
     fmt::{Debug, Display, Formatter},
     ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign},
@@ -27,7 +27,11 @@ pub struct Fixed<const SHIFT: u32>(i32);
 /// A length or a coordinate in pixels, to a sixty-fourth. Finer than anything
 /// a display can show, and exact in `f32` up to 262,144 px, which is what lets
 /// the same number reach the GPU.
-pub type Px = Fixed<6>;
+pub type Px = Fixed<PX_SHIFT>;
+
+/// How many bits of a pixel a [`Px`] keeps. One place, because [`PxVec2`]
+/// and the shader's own decoding are the same grid or nothing lines up.
+pub const PX_SHIFT: u32 = 10;
 
 /// A share of what a box has left over, which is a weight beside its
 /// siblings rather than a fraction of anything: a list divides its room by
@@ -40,7 +44,11 @@ pub type Weight = Fixed<16>;
 /// +/-128 of range, enough to sum a hundred children each asking for a whole
 /// box. A `leftover` weight is not one of these: it is a share of what is
 /// left rather than a fraction of anything, and it sums over a whole list.
-pub type Rel = Fixed<24>;
+pub type Rel = Fixed<REL_SHIFT>;
+
+/// How many bits of a box a [`Rel`] keeps, beside [`PX_SHIFT`] and for the
+/// same reason.
+pub const REL_SHIFT: u32 = 24;
 
 impl<const SHIFT: u32> Fixed<SHIFT> {
     pub const ZERO: Self = Self(0);
@@ -135,6 +143,15 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         Self(narrow(self.0 as i64 * by as i64))
     }
 
+    /// Divided into a whole number of parts, rounded to the nearest step.
+    pub const fn div_int(self, by: i32) -> Self {
+        debug_assert!(by != 0, "no part of nothing");
+        if by == 0 {
+            return Self::ZERO;
+        }
+        Self(narrow(div_round(self.0 as i64, by as i64)))
+    }
+
     /// Divided by a number on any grid. A zero divisor is a caller bug -- a
     /// box of no length has no fraction of itself -- and saturates so that a
     /// release build lays out something absurd rather than dying.
@@ -221,7 +238,19 @@ const fn div_round(num: i64, den: i64) -> i64 {
     }
 }
 
-const fn narrow(v: i64) -> i32 {
+/// Toward positive infinity when `up`, toward negative infinity otherwise.
+pub(crate) const fn div_toward(num: i64, den: i64, up: bool) -> i64 {
+    let (q, rem) = (num / den, num % den);
+    if rem == 0 {
+        return q;
+    }
+    match (rem < 0) == (den < 0) {
+        true => q + up as i64,
+        false => q - !up as i64,
+    }
+}
+
+pub(crate) const fn narrow(v: i64) -> i32 {
     if v > i32::MAX as i64 {
         return i32::MAX;
     }
@@ -297,6 +326,91 @@ impl<const SHIFT: u32> Debug for Fixed<SHIFT> {
     }
 }
 
+/// Two of them, for the places a size or a position needs both axes: a
+/// window, a box in pixels, a pointer. Held apart from [`crate::util::Vec2`]
+/// because that one is what the GPU and the platform speak.
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub struct FixedVec2<const SHIFT: u32> {
+    pub x: Fixed<SHIFT>,
+    pub y: Fixed<SHIFT>,
+}
+
+pub type PxVec2 = FixedVec2<PX_SHIFT>;
+
+impl<const SHIFT: u32> FixedVec2<SHIFT> {
+    pub const ZERO: Self = Self::splat(Fixed::ZERO);
+
+    pub const fn new(x: Fixed<SHIFT>, y: Fixed<SHIFT>) -> Self {
+        Self { x, y }
+    }
+
+    pub const fn splat(v: Fixed<SHIFT>) -> Self {
+        Self { x: v, y: v }
+    }
+
+    pub fn from_f32(v: Vec2) -> Self {
+        Self::new(Fixed::from_f32(v.x), Fixed::from_f32(v.y))
+    }
+
+    pub fn to_f32(self) -> Vec2 {
+        Vec2::new(self.x.to_f32(), self.y.to_f32())
+    }
+
+    pub const fn div_int(self, by: i32) -> Self {
+        Self::new(self.x.div_int(by), self.y.div_int(by))
+    }
+
+    pub const fn min(self, other: Self) -> Self {
+        Self::new(self.x.min(other.x), self.y.min(other.y))
+    }
+
+    pub const fn max(self, other: Self) -> Self {
+        Self::new(self.x.max(other.x), self.y.max(other.y))
+    }
+}
+
+// `impl_op!` names one concrete type, and this one is generic.
+const impl<const SHIFT: u32> Add for FixedVec2<SHIFT> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Self::new(self.x.add(rhs.x), self.y.add(rhs.y))
+    }
+}
+
+const impl<const SHIFT: u32> Sub for FixedVec2<SHIFT> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self {
+        Self::new(self.x.sub(rhs.x), self.y.sub(rhs.y))
+    }
+}
+
+const impl<const SHIFT: u32> AddAssign for FixedVec2<SHIFT> {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = Add::add(*self, rhs);
+    }
+}
+
+const impl<const SHIFT: u32> SubAssign for FixedVec2<SHIFT> {
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = Sub::sub(*self, rhs);
+    }
+}
+
+impl<const SHIFT: u32> Debug for FixedVec2<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+impl<const SHIFT: u32> Display for FixedVec2<SHIFT> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -332,10 +446,10 @@ mod tests {
 
     #[test]
     fn halves_round_away_from_zero_either_side() {
-        // A sixty-fourth and a half of one, which has no step of its own.
-        let one_and_a_half = Rel::from_f32(1.5) / Rel::from_int(64);
-        assert_eq!(Px::ONE * one_and_a_half, Px::from_raw(2));
-        assert_eq!(Px::ONE.neg() * one_and_a_half, Px::from_raw(-2));
+        // A step and a half of one, which has no step of its own.
+        let step_and_a_half = Rel::from_f32(1.5).div_int(Px::ONE.raw());
+        assert_eq!(Px::ONE * step_and_a_half, Px::from_raw(2));
+        assert_eq!(Px::ONE.neg() * step_and_a_half, Px::from_raw(-2));
     }
 
     #[test]
@@ -360,10 +474,8 @@ mod tests {
         // A third, which neither grid holds exactly.
         let third = Rel::ONE / Rel::from_int(3);
         assert_eq!(third.to_scale::<6>(), Fixed::<6>::from_raw(21));
-        assert_eq!(
-            Px::from_raw(21).to_scale::<24>().to_scale::<6>(),
-            Px::from_raw(21)
-        );
+        let coarse = Fixed::<6>::from_raw(21);
+        assert_eq!(coarse.to_scale::<24>().to_scale::<6>(), coarse);
     }
 
     #[test]