Carry a length as a rule beside a widget, not a widget around it

`.width()` built a `SetSize` whose whole job was to answer `size_hint`, so
every declared length cost a widget, an `ActiveData` and a link of chain to
say one number. It is now a `SizeRule` per axis on `WidgetData`, beside
`region_node`, resolved by `Painter` where the widget is drawn. `SetSize`
and `MaxSize` are gone; `MaxSize` had no caller but its own builders.

That settles which of two answers is the size. A rule wins on the axis it
names and the `Size` returned by `draw` answers the rest, applied once in
`draw_inner` rather than by each widget that could carry one -- so the
widget under a rule never learns of it. `Painter::size_hint` reads the rule
first for the same reason: a rule that beats what a widget would draw has
to beat what it says about itself.

`declared_lens` still falls back to a non-leftover `size_hint`, which is
how an image or a gap gets its own pixel size rather than the whole offer.
That is the offer's business rather than a declaration's, and it falls away
when a widget occupies its reported size inside the box it was offered.

`known` and `declared` are separate because a share is a length to whoever
divides one and not to whoever composes a box: `.width(leftover(3))` is
known without drawing but cannot narrow anything.

Checked: fmt, clippy, 85 tests, and 100 generated seeds agreeing warm
against cold in 67.6 s. `minimal`, `text` and `view` render byte-identical
at 1920x1200; `tabs` differs only in the widget count it prints about
itself, which is two wrapper types smaller.

src/random.rs

@@ -8,14 +8,14 @@
 use crate::prelude::*;
 use std::collections::HashMap;
 
-/// The declared lengths of one `SetSize`, by axis.
+/// The declared lengths of one widget carrying a size rule, by axis.
 pub type Lens = [Option<Len>; 2];
 
 /// What a test changes between two trees grown from the same seed, so the
 /// warm one can be mutated and the cold one grown that way to begin with.
 #[derive(Default)]
 pub struct Edits {
-    /// Declared sizes, by the order the `SetSize` wrappers were made.
+    /// Declared sizes, by the order the rules were put on.
     pub sizes: HashMap<usize, Lens>,
     /// Which children a span has, by the order the spans were made.
     pub spans: HashMap<usize, SpanEdit>,
@@ -75,7 +75,7 @@ const WORDS: &str = "Wrapping shapes one source into as many lines as the box \
 #[derive(Default)]
 pub struct Tree {
     pub ids: Vec<WidgetId>,
-    pub sized: Vec<WeakWidget<SetSize>>,
+    pub sized: Vec<WidgetId>,
     pub spans: Vec<Spanned>,
     pub scrolls: Vec<WeakWidget<Scroll>>,
     /// Children a `SpanEdit` took out, held so that dropping the last share
@@ -201,15 +201,13 @@ impl<Rsc: UiRsc + 'static> Grow<'_, Rsc> {
         let idx = self.tree.sized.len();
         let lens = [self.len(), self.len()];
         let lens = self.edits.sizes.get(&idx).copied().unwrap_or(lens);
-        let id = SetSize {
-            inner,
-            x: lens[0],
-            y: lens[1],
-        }
-        .add(self.rsc);
+        let id = inner.id();
+        self.rsc
+            .ui_mut()
+            .widgets
+            .set_size_rules(id, lens[0], lens[1]);
         self.tree.sized.push(id);
-        self.tree.ids.push(id.id());
-        id.add_strong(self.rsc)
+        inner
     }
 
     fn node(&mut self, depth: usize) -> StrongWidget {