Give a slot to the children a container places, and nothing else

A widget's region is now held in the coordinates of the slot it draws in
rather than the window's, and `Painter::place` is how a container asks for a
slot: it draws a child it decides the box of and may decide again. Everything
under that slot is a fraction of its box, so placing the child a second time
is one entry to write whether it moved or changed length. A child drawn any
other way has no slot and shares its nearest ancestor's.

That is what keeps the chain short. `chain_cost` measured depth as the cost
-- free to 8, +42.6% at 16 -- and a slot per widget put a transcript's glyphs
past that for nothing, since almost every slot was zero. `Span`, `Aligned`
and `Scroll` are the containers that re-place a child after drawing it, and
`tests/layout.rs` pins that four widgets between a span and a leaf leave the
leaf's chain one deep.

`UiRegion::stretch`, `UiRegion::stretchable` and `UiScalar::stretch` are
gone. Nothing is inverted any more: a box that changed length is written to
its slot, and the descendants recompose against it in the shader. That also
retires the case the guard existed for, where a fixed length has no fraction
to recover -- `tests/layout.rs` now stretches a 40-tall row on its other
axis, which `stretchable` refused outright.

What still walks the CPU is deciding who must draw again, which no chain can
answer: `mark_resized` descends from the widget whose box changed and marks
anything whose own box changed length and whose drawing reads it. A part of
a box with no relative extent on an axis is a fixed length, and composing
into it leaves none either, so the walk stops where a length did not change
-- an 80-wide child in a widened row is not redrawn though it says `Redraw`.

`Span`, `Pad`, `Stack`, `Offset`, `Aligned`, `SetSize` and `LayerOffset` say
`Scale`: each places in fractions and offsets of its own box and none reads
the box's pixel length. `Scroll` and `MaxSize` do read pixels and stay
`Redraw`.

45 tests pass, five of them new. Render verification comes after the CPU
side, per the owner.

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

tests/layout.rs

@@ -126,3 +126,59 @@ fn a_moved_subtree_takes_its_children_with_it() {
     // `inner`'s own region was never rewritten.
     assert_corners!(h, inner, (10, 90), (390, 110));
 }
+
+#[test]
+fn a_fixed_length_child_keeps_it_when_the_box_around_it_grows() {
+    let mut h = Harness::new((400, 200));
+    let fixed = rect(Color::BLUE).width(50).add(&mut h.rsc);
+    let rest = rect(Color::GREEN).add(&mut h.rsc);
+    let panel = (fixed, rest).span(Dir::RIGHT).add(&mut h.rsc);
+    // Changing the bar's width is the only thing that changes the box the
+    // panel and everything under it was drawn for.
+    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
+    h.set_root((bar, panel).span(Dir::RIGHT));
+    assert_corners!(h, fixed, (100, 0), (150, 200));
+    assert_corners!(h, rest, (150, 0), (400, 200));
+
+    h.rsc[bar].x = Some(Len::abs(200));
+    h.frame();
+
+    // The panel's box is 100 shorter, so the fixed child is the same 50 wide
+    // against its new start and the one taking the rest absorbs the change.
+    assert_corners!(h, fixed, (200, 0), (250, 200));
+    assert_corners!(h, rest, (250, 0), (400, 200));
+}
+
+#[test]
+fn a_box_with_a_fixed_length_can_be_stretched_on_its_other_axis() {
+    let mut h = Harness::new((400, 200));
+    // The row is 40 tall whatever happens, which used to make its drawing
+    // impossible to take out of: recovering a fraction of a box needs a
+    // relative extent, and it has none on that axis.
+    let inner = rect(Color::BLUE).add(&mut h.rsc);
+    let row = inner.pad(10).height(40).add(&mut h.rsc);
+    let filler = rect(Color::GREEN).add(&mut h.rsc);
+    let column = (row, filler).span(Dir::DOWN).add(&mut h.rsc);
+    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
+    h.set_root((bar, column).span(Dir::RIGHT));
+    assert_corners!(h, inner, (110, 10), (390, 30));
+
+    h.rsc[bar].x = Some(Len::abs(200));
+    h.frame();
+
+    assert_corners!(h, inner, (210, 10), (390, 30));
+}
+
+#[test]
+fn only_a_container_that_places_its_children_lengthens_the_chain() {
+    let mut h = Harness::new((400, 200));
+    let leaf = rect(Color::BLUE).add(&mut h.rsc);
+    // Four widgets between the span and the leaf, none of which places what
+    // it draws, so all of them share the span's slot.
+    let buried = leaf.pad(4).pad(4).pad(4).pad(4).add(&mut h.rsc);
+    let bar = rect(Color::RED).width(100).add(&mut h.rsc);
+    h.set_root((bar, buried).span(Dir::RIGHT));
+
+    let slot = h.render.active[&leaf.id()].parent_move;
+    assert_eq!(h.render.moves.depth(slot), 1, "one span above the leaf");
+}