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)
 }

tests/layout_dump.rs

@@ -8,10 +8,10 @@
 //!
 //! then the same after, and `diff` the two. A line is one widget: the seed,
 //! its index in creation order, and its box in window pixels, or `-` where
-//! it is not drawn.
+//! it is not drawn. `IRIS_UNBOUNDED=1` drops the trees' intrinsic bounds, as
+//! in the diagnostics rig, which compares the two paths over the same shapes.
 
 use iris::harness::Harness;
-use iris::prelude::{Axis, Bound, SizeRule};
 use iris::random::{Edits, build, plan};
 
 fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
@@ -30,16 +30,8 @@ fn every_cold_layout_is_printed() {
     for seed in 1..=seeds {
         let mut harness = Harness::new((1920.0, 1200.0));
         let mut plan = plan(seed, depth, &Edits::default());
-        if std::env::var_os("IRIS_DUMP_UNBOUNDED").is_some() {
-            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;
-                        }
-                    }
-                }
-            });
+        if env("IRIS_UNBOUNDED", 0_u8) != 0 {
+            plan.drop_bounds();
         }
         let (root, tree) = build(&mut harness.rsc, &plan);
         harness.state.root = Some(root);