Say a length that is zero, and share the seed a scan takes

A full sweep of #19, and the first review of f48e04e.

`Display for LayoutLen` leaves out every part that is zero, so
`LayoutLen::ZERO` printed as the empty string -- and `Debug` forwards to
`Display` since the last commit, so the four `assert_eq!`s in
`cases/deferred.rs` print nothing where a request of zero is, and
`scenario::describe` prints a `.width(0)` rule as `-`, which is what it
prints for a widget that has no rule at all. That file exists so a tree a
fuzzer found can be written out by hand; a value it cannot say is a hole in
the one thing it is for.

`Fixed::ceil_from_f32` took `next_up` of a `from_f32` that had already
clamped, and `next_up` wraps, so a measurement past the top of the grid came
back as the bottom of it. `from_f32` clamps deliberately because a float has
further to come from; the ceiling is the other way in from a float and now
holds to the same rule. The check goes beside the one `from_f32` already
had.

`Moves::depth` walked the move chain a second way, with its own copy of
`CHAIN_LIMIT` and without the assertion `walk` makes; it is `walk` now, so
the CPU counts the chain in one place and the shader's constant reaches
both.

`Harness::set_len` said it set a length "the way `.width()` sets one" and
wrote the whole rule instead, dropping any bound beside it. A case that set
a bound and then a length would have passed with no bound at all.

Three rigs each spelled "one seed, or a range of them" by hand -- the class
the eleventh sweep closed for reading a parameter and not for this. There is
one `rig::seeds` now. `cases/deferred` was last in `suite.rs`'s otherwise
alphabetical list.

`diag::outside` writes out `AxisHolds::contains`'s four clauses to say which
one refused a reuse; a debug assertion now catches a fifth clause added
there and not here, which would leave a refusal counted and unexplained.

`Sow::bound`'s comment recorded an open hole reached by seeds 4 and 196 at
depth 5 -- but `generated.rs` says seeds stopped naming those trees when the
leaves grew images, and 600 depth-5 trees over all sixteen cases agree warm
against cold with every bound a fraction. The comment says what is true now
and why the generator still grows pixels.

Format, workspace clippy under -D warnings with and without
layout-diagnostics, 208 ordinary and 212 diagnostic tests (207 and 211
before, plus the one this adds), and the cold dump byte-identical to
f48e04e across all 34,986 boxes. The three seed scans were not run: nothing
here can move a box, which the dump confirms.

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

core/src/orientation/len.rs

@@ -247,6 +247,12 @@ impl std::fmt::Display for Size {
 
 impl std::fmt::Display for LayoutLen {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // A part that is zero is left out, so a length that is zero all
+        // through would print as nothing -- which reads as no length at all
+        // wherever one is printed beside something that has none.
+        if *self == Self::ZERO {
+            return write!(f, "0 px;");
+        }
         if self.px != Px::ZERO {
             write!(f, "{} px;", self.px)?;
         }
@@ -261,3 +267,24 @@ impl std::fmt::Display for LayoutLen {
 }
 
 impl_axis_index!(Size => LayoutLen);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// What a request prints as is how a failing case is read and written out
+    /// again, and a length that printed as nothing could not be told from a
+    /// widget that has no rule at all.
+    #[test]
+    fn every_length_prints_as_something() {
+        for len in [
+            LayoutLen::ZERO,
+            LayoutLen::px(8),
+            LayoutLen::rel(0.5),
+            LayoutLen::LEFTOVER,
+        ] {
+            assert!(!len.to_string().is_empty(), "{len:?} printed as nothing");
+        }
+        assert_eq!(LayoutLen::ZERO.to_string(), "0 px;");
+    }
+}