Hold a bound's length where it is decided, and say each thing once

A quality sweep over the deferred request system, which no earlier round
has reviewed.

`Bound::outside` said which end a length fell outside and left the caller
to look that end up through `Bound::at`, which `expect`s an end the value
it is given does not promise: only the pairing of the two calls kept
`at(Shorter)` off a bound with no floor. It already had the length in
hand, so it returns that, and `Outside` and `at` go with the state that
could panic.

`measured_request` pinned the rel base for any bound at all, so a measured
share under a cap in pixels was invalidated by a change to a base its
answer cannot depend on. That question is `Bound::has_fraction` now, which
is also the one `Placing::ask` and `SizeRule::has_fraction` were each
writing out over a bare array.

The rest is one name where there were several spellings: `Span::gaps`,
`Padding::along`, `Plan::drop_bounds` behind one `IRIS_UNBOUNDED` in both
rigs that had grown their own, and `Stack::size_request` resolving its
sizing child the way its draw already does. `Span`'s placement loop asked
three times whether the row was allocated, twice to decide one child's
length; one match answers all three, so the allocated and plain rules are
read side by side.

The buffers `draw_at` now reuses for their capacity are empty only because
every path to it drains them in `remove`; a `debug_assert` says so, since
a drawing over primitives left in one would record them twice.

Comments: `with_requests` named discovery as the hazard where it is a
child drawn mid-row, `Painter::allocate` documented the window it holds
for rather than what it does, `minimum_request` had none, and the note
saying a span carries its children's weight whole -- which is still what
the unallocated path does, and still the surprising part -- had been
replaced by one about the other path.

tests/layout_diagnostics.rs

@@ -129,15 +129,7 @@ fn rig_edits() -> Edits {
 fn fixture(harness: &mut Harness, seed: u64, depth: usize) -> (StrongWidget, Tree) {
     let mut plan = plan(seed, depth, &rig_edits());
     if env("IRIS_UNBOUNDED", 0_u8) != 0 {
-        plan.walk_mut(&mut |node| {
-            if let Some(rules) = &mut node.size {
-                for axis in Axis::BOTH {
-                    if rules[axis].bound() != Bound::ANY {
-                        rules[axis] = SizeRule::Free;
-                    }
-                }
-            }
-        });
+        plan.drop_bounds();
     }
     build(&mut harness.rsc, &plan)
 }