Say the environment once, and stop a hint read going uncounted

The eleventh sweep, over the built-in bounds work in 2ac0843.

`Painter::size_hint` refused to answer for a bounded widget by returning
above the diagnostics, so that read was neither a hint hit nor a miss and
`hint_read` recorded nothing. It is a miss now, with the reason on it.

The two `for axis in Axis::BOTH` loops that `draw_widget` grew, both
writing `own_holds`, are one loop, and the comment about combining the
ask's holds no longer sits between a comment and the code it describes.

`Declared::from_axes` lost its only caller with `Widgets::declared_lens`;
`Bounds::from_axes` and `SizeRule::declared` never had one.

The scenario shrinker printed a rule with derived `Debug`, which is 130
characters an axis in a line that carries every ancestor, in the one
function whose job is output a tree can be rebuilt from. It prints its
parts again.

`bounds_cost` invented three environment-reading spellings where four
copies of one `env` helper already existed; there is now one, in
`tests/rig`, and the four copies are gone. It also verified 128 regions
inside its measured loop, which the other rigs deliberately do before
theirs; that measured 0.65% of the total, and none of it is layout.

The 250-window row with a 300 cap was built by two tests, and the one
that still explained itself tested less; they are one. The half of
`a_cap_attribute_narrows_the_widgets_box` that the wrapper's removal left
without its deciding assertion is the allocator's path instead, which
nothing at the root covered.

Format, workspace clippy under -D warnings with and without
layout-diagnostics, 206 ordinary and 210 diagnostic tests, 400 depth-5
trees warm against cold in 64.19s, and the cold dump byte-identical to
2ac0843 across all 34,986 boxes.

core/src/ui/render_state.rs

@@ -452,23 +452,34 @@ impl UiRenderState {
             x: ruled(Axis::X, size.x),
             y: ruled(Axis::Y, size.y),
         };
-        // A bound is a promise about the length as well as about the box: a
-        // widget that drew past the box it was given -- a text too tall for
-        // it, an image at its own size under a cap -- is still held to what
-        // its rule allows.
-        //
-        // Held here rather than taken from the box, even where the bound
-        // decided that box. What a widget answers is its own, and a bound
-        // that replaced the answer would make a share into a fixed length
-        // the moment a box was long enough -- which is a length the span
-        // dividing that box decided from this answer, so the two would
-        // choose each other. A share is left alone here for the same reason:
-        // it is a length only to whoever divides one, and the box that
-        // divider gives is a box this widget is asked in, where the bound is
-        // applied to it.
-        // Widgets may widen their own read ranges, but not the ask's constraints.
+        // What the drawing read is combined with what the ask decided rather
+        // than replacing it: a widget may widen its own ranges, and cannot
+        // widen the ask's.
         let mut own_holds = own.and(info.ask_holds);
         for axis in Axis::BOTH {
+            // A rule that is a fraction of the rel base is answered with the
+            // rel base's own length, so the answer is that rel base's and not
+            // just that many pixels of this window -- the same pin a widget
+            // that read its rel base took for its drawing. A bound counts:
+            // which side of it the box fell was decided against this rel
+            // base, and the same box of a different one can fall on the other.
+            if rules[axis].has_fraction() {
+                own_holds[axis].rel_base = Some(info.rel_base[axis]);
+            }
+            // A bound is a promise about the length as well as about the box:
+            // a widget that drew past the box it was given -- a text too tall
+            // for it, an image at its own size under a cap -- is still held to
+            // what its rule allows.
+            //
+            // Held here rather than taken from the box, even where the bound
+            // decided that box. What a widget answers is its own, and a bound
+            // that replaced the answer would make a share into a fixed length
+            // the moment a box was long enough -- which is a length the span
+            // dividing that box decided from this answer, so the two would
+            // choose each other. A share is left alone here for the same
+            // reason: it is a length only to whoever divides one, and the box
+            // that divider gives is a box this widget is asked in, where the
+            // bound is applied to it.
             let answer = size[axis];
             if answer.leftover != Weight::ZERO {
                 continue;
@@ -479,17 +490,6 @@ impl UiRenderState {
                 size[axis] = held.into();
             }
         }
-        // A rule that is a fraction of the rel base is answered with the
-        // rel base's own length, so the answer is that rel base's and not just
-        // that many pixels of this window -- the same pin a widget that read
-        // its rel base took for its drawing. A bound counts: which side of it
-        // the box fell was decided against this rel base, and the same box of
-        // a different one can fall on the other.
-        for axis in Axis::BOTH {
-            if rules[axis].has_fraction() {
-                own_holds[axis].rel_base = Some(info.rel_base[axis]);
-            }
-        }
         // A widget that clipped its contents to its box drew nothing outside
         // it, so reporting more than the box asks to be placed at a length it
         // does not occupy -- and its parent would place the part it cut off.