Say what a child gets of a container's box in that box's own lengths

Three things the measurements asked for, all about how much a box that came
from an answer costs.

**A part in the box's own coordinates.** Saying "less eleven pixels at the
end" in frame lengths from the box's start means reading how long the box is,
and a container whose box is its own answer then depends on its own answer:
`Pad` drew sixty-four times in one resize frame at seed 13, chasing its own
width. `Part::Of` says the same thing as a part of the box, which composes
without a length -- pixels are pixels wherever the box lands -- and what a
child under it holds for maps back through that part onto the container's
own box rather than onto the frame.

**One axis of the box at a time.** `extent_len` pinned both axes, so a span
dividing one of them held for one length of the other as well, and a resize
broke every span whose cross-axis answer moved.

**No lazy placement.** Leaving a child's answer to be placed at the end of
the parent's draw, rather than as the child answers, was meant to save a
recomposition. It costs one instead: the drawing is put in the part first
and in the answer's box after, and where it does not hold for both that is
two drawings rather than one. Seed 1 at depth 8 went from 391 widget draws
on a resize to 29 with it gone. The test that pinned three draws for a
numeric leaf in a span goes with it.

Seed 1 at depth 8, widget draws / distinct widgets / update, against #18's
head and against the commit this branch started from:

| phase   | e44dea3      | 34cafb6      | here          |
| ---     | ---          | ---          | ---           |
| cold    | 369/261/10.6 | 463/274/13.3 | 516/288/12.0  |
| repaint | 1            | 1            | 1             |
| many    | 157/95/0.33  | 263/108/0.59 | 187/119/0.52  |
| size    | 16/12/0.018  | 3/3          | 3/3/0.010     |
| scroll  | 2/0.002      | 1            | 1/0.004       |
| resize  | 13/13/0.019  | 22/15/0.032  | 24/76/0.090   |

Seed 13 at depth 8 is where the protocol still costs: `many` 1091 draws
against #18's 524, and `resize` 2215 against a frame #18 does not draw at
all. Both are the same shape -- an answer measured in one box and drawn in
another -- and the handoff says where that comes from.

Checked: fmt, clippy with -D warnings, 108 suite tests, 20 core tests, the
11 generated cases, and the shrinker at 400 trees of depth 5, which fails
seeds 2 (repaint) and 108 (reorder).

core/src/ui/place.rs

@@ -1,23 +1,47 @@
 use crate::{PrimitiveHandle, UiRegion, UiSpan};
 
-/// Where a child goes along one axis, as a part of this widget's extent.
-/// Spans are frame lengths from the extent's start, so a span's slot is
-/// `from..start` and a moved extent re-places every child by re-adding its
-/// start, exactly. `None` is the whole extent.
+/// What of a widget's own box a child is given, along one axis.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Part {
+    /// The whole of it.
+    All,
+    /// Frame lengths from where the box starts, which is what a container
+    /// dividing room among its children speaks: a child's report is a length
+    /// of the frame, so the cursor that sums those reports is one too. A
+    /// moved box re-places every child by re-adding its start, exactly.
+    From(UiSpan),
+    /// A part of the box in its own coordinates, which is what a container
+    /// that insets one speaks: taking eleven pixels off the end needs no
+    /// length, where saying the same thing in frame lengths would make the
+    /// container read its own box -- and a box chosen from its own answer
+    /// then feeds back into the answer.
+    Of(UiSpan),
+}
+
+impl Part {
+    /// Where it lands in the coordinates `extent` is in.
+    pub(crate) fn of(self, extent: UiSpan) -> UiSpan {
+        match self {
+            Self::All => extent,
+            Self::From(span) => UiSpan::new(extent.start + span.start, extent.start + span.end),
+            Self::Of(span) => span.within(&extent),
+        }
+    }
+}
+
+/// Where a child goes along one axis, as a part of this widget's box.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Place {
     /// The child's answer, aligned inside the part by the child's alignment.
-    Within(Option<UiSpan>),
+    Within(Part),
     /// Exactly the part; the answer is not placed inside it again.
-    Fill(Option<UiSpan>),
+    Fill(Part),
 }
 
 impl Place {
-    /// The part, where the caller named one rather than giving the whole
-    /// extent.
-    pub(crate) fn span(self) -> Option<UiSpan> {
+    pub(crate) fn part(self) -> Part {
         match self {
-            Self::Within(span) | Self::Fill(span) => span,
+            Self::Within(part) | Self::Fill(part) => part,
         }
     }
 
@@ -28,8 +52,8 @@ impl Place {
     }
 }
 
-/// A primitive as it was written: its box in the widget's extent
-/// coordinates, which is what a move of that extent re-composes from.
+/// A primitive as it was written: its box in the widget's own box's
+/// coordinates, which is what a move of that box re-composes from.
 #[derive(Debug)]
 pub struct RetainedPrimitive {
     pub handle: PrimitiveHandle,