Ask a value a question through a reference

A method taking `self` can only be called on a value, so anywhere the caller
holds a reference it has to dereference to ask -- which costs the caller
whether or not the type is `Copy` (Bryan, 2026-09-20, correcting the opposite
change made in 7502176).

So every method that answers a question about a value takes `&self`:
`Holds`'s four, `AxisHolds` and `LayoutHolds`'s three each, `LayoutLen`'s
`is_px`, `is_only_leftover`, `declared` and `fills`, and `Size::within_box`.
The two callers passing `LayoutLen::declared` as a function value say the
closure instead.

Builders that return a changed copy, and methods on a handle that is meant to
be given up, still take `self`.

core/src/ui/holds.rs

@@ -29,17 +29,17 @@ impl Holds {
         Self { lo: len, hi: len }
     }
 
-    pub const fn contains(self, len: Px) -> bool {
+    pub const fn contains(&self, len: Px) -> bool {
         len.raw() >= self.lo.raw() && len.raw() <= self.hi.raw()
     }
 
     /// Every length `other` holds for is one this holds for, so a drawing
     /// made under this range is still good wherever `other` is.
-    pub const fn covers(self, other: Self) -> bool {
+    pub const fn covers(&self, other: Self) -> bool {
         self.lo.raw() <= other.lo.raw() && self.hi.raw() >= other.hi.raw()
     }
 
-    pub const fn and(self, other: Self) -> Self {
+    pub const fn and(&self, other: Self) -> Self {
         Self {
             lo: self.lo.max(other.lo),
             hi: self.hi.min(other.hi),
@@ -57,7 +57,7 @@ impl Holds {
     /// boxes therefore give one length. That is a floor rather than an
     /// allowance: inverting it is two divisions and nothing else, and the
     /// whole of a box maps back to itself.
-    pub const fn through(self, len: Len) -> Self {
+    pub const fn through(&self, len: Len) -> Self {
         if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
             return Self::ANY;
         }