Delete OrthoSize, and run the seeds in parallel

A span is as long across itself as its longest child, unless a rule beside it
already says how long it is -- and then reading the children answers nothing
and only makes its size depend on theirs. `OrthoSize::Full` was that second
case written twice, once as an enum on the span and once as the rule that
actually decides; `Painter::ruled` lets the span ask which it is in. The
widget under a rule still does not learn what the rule says, only that its
answer for that axis is not wanted.

The fuzzers grow, lay out and drop a tree within one seed, so the seeds share
nothing and take a thread each, one short of every core. Measured here: the
generated oracle's hundred seeds went from 68 s to 10 s, and a shrinker case
at 300 seeds from 18 s to 3.5 s. A seed that fails still shrinks and panics
on its own thread, and `std::thread::scope` carries that out.

The shrinker now allows the two steps the oracle already did -- the deeper
trees these grow reach a second composition, and a step is a thousandth of a
pixel.

Checked: fmt, clippy, 102 tests, all five shrinker cases at 300 seeds, 100
generated seeds, and five examples byte-identical at 1920x1200.

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

core/src/ui/painter.rs

@@ -353,6 +353,20 @@ impl<'a> Painter<'a> {
         self.rsc.widgets().alignment(self.id)
     }
 
+    /// Whether a rule beside this widget settles its length on `axis`, which
+    /// makes whatever it reports for that axis moot. The widget under a rule
+    /// does not otherwise learn of it -- this is for a container deciding
+    /// whether reading its children across an axis is worth anything, since
+    /// reading one is also what makes its own size depend on it.
+    pub fn ruled(&self, axis: Axis) -> bool {
+        self.rsc
+            .widgets()
+            .size_rules(self.id)
+            .axis(axis)
+            .known()
+            .is_some()
+    }
+
     /// The part of this widget's box that something of `size` takes, at the
     /// near edge. A container that reports one child's size gives every child
     /// this, so what it draws is inside what it says it occupies.