iris: the arenas upload deltas, and stop being 11x bigger than the tree

Changing any primitive re-uploaded every primitive. Measured over the
bench fixture by the new arena_churn rig: 758 MB across a fling and
1.2 GB across 401 streamed deltas, p50 3.0 MB per streamed frame.

Three separate things were wrong, and only the first is what it looked
like from the outside.

ArrBuf reallocated on every length change. A fresh Buffer's contents are
undefined, so adding one glyph -- which a streamed reply does constantly
-- forced a full rewrite, and no partial upload could have been correct
in the first place. It has a capacity now, growing geometrically and
never shrinking, and update() answers whether the Buffer identity moved
so a caller can rebuild its bind group and force the whole range dirty.
That alone took the glyph array from 95% re-uploaded to 3%, and stopped
primitive_group being rebuilt on every frame the arena changed.

A redraw freed its primitives and pushed new ones. Freed slots are not
reusable until the end of the frame -- a layer's draw order still names
them -- and Painter::draw_twice is how a container learns a child's
size, so with containers nested the arena's high-water was the transient
push count rather than the live one: 17 million pushes across 401
deltas, 127,443 slots for 11,569 live primitives, growing linearly with
the transcript. A redraw now gets its old handles back as a recycle pool
(Painter::take_recycled, Primitives::recycle) and writes into the slots
it already holds; the pool is consumed in order and whatever the draw
does not claim is freed when it ends. The arena is exactly the live
count now. The CPU frame improved with it, from p50 2.20ms to 1.39ms on
the stream run, because the freeing and the draw-order renumbering went
away.

Nothing tracked which entries changed. util::Dirty is a bitset per
uploaded array, coalesced into ranges at a 1 KiB gap. Marking is O(1)
and allocation-free; reading it back is one word per 64 entries. Both
alternatives were measured and rejected: a min..max span is nearly the
whole buffer, since a frame's changes land in 5-20 scattered runs, and a
Vec of indices would mean an allocation and a sort per frame at several
thousand marks. It replaces Primitives::updated -- one bool that covered
the instances and the per-primitive data together, so rewriting a rect's
region re-uploaded every glyph -- and TrackedArena::changed.

The trap only the rig could catch: writing an entry is not changing it.
Recycling rewrote every glyph of every moved row with identical bytes,
marking 73% of the glyph array against 0.6% genuinely changed, because
what moves is the instance's region and not the glyph. PrimitiveVec::set
and Primitives::set_instance compare before marking.

Every array now uploads within a hair of its floor: fling instances 3.4%
against 3.3%, fling glyphs 0.9% against 0.8%, stream glyphs 0.6% against
0.6%. Stream instances are at 72.7%, which *is* the floor and is a
layout question rather than an upload one -- the list is pinned to the
newest end, so a growing reply moves every row, and that should be one
move_offsets write rather than a redraw. Noted in RUST.md as the next
thing.

Also: draw_inner's four old_* parameters become one Retained struct, so
the recycle pool is a field rather than an eleventh positional argument
next to three others of the same shape; and free_primitive is the one
place a slot and its draw-order position are retired together.

The rigs move to scripts/rigs/ui-profile, a crate of their own so a
rig's dependencies stay out of the app's -- arena_churn needs bytemuck,
which nothing in ai-app does. arena_churn prints floor, uploaded and
whole side by side per array, because any two of those alone are
misleading and the 122x over-marking above was invisible until all three
were on screen together.

core/src/ui/painter.rs

@@ -2,8 +2,8 @@ use crate::{
     Color, RenderedText, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
     UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, WidgetId,
     render::{
-        Drawn, GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveHandle, PrimitiveInst,
-        RectPrimitive,
+        Drawn, GlyphPrimitive, IMAGE_BINDING, Mask, MaskIdx, MoveIdx, NOT_DRAWN, Primitive,
+        PrimitiveHandle, PrimitiveInst, RectPrimitive,
     },
     util::Vec2,
 };
@@ -22,6 +22,17 @@ pub struct Painter<'a> {
     pub(super) own_mask: MaskIdx,
     pub(super) textures: Vec<TextureHandle>,
     pub(super) primitives: Vec<PrimitiveHandle>,
+    /// The handles this widget owned before *this* draw, offered back to
+    /// it in the order it wrote them last time -- see
+    /// [`Self::take_recycled`]. Empty for a widget being drawn for the
+    /// first time. Whatever is left when the draw ends is genuinely gone,
+    /// and `UiRenderState::draw_inner` frees the remainder.
+    ///
+    /// An iterator rather than a vec and a cursor because a
+    /// `PrimitiveHandle` is an ownership token and deliberately not
+    /// `Clone`: `peek` asks whether the next one fits without taking it,
+    /// `next` takes it, and what is left is exactly what nothing claimed.
+    pub(super) recycle: std::iter::Peekable<std::vec::IntoIter<PrimitiveHandle>>,
     pub(super) children: Vec<WidgetId>,
     pub layer: usize,
     pub(super) id: WidgetId,
@@ -32,6 +43,29 @@ impl<'a> Painter<'a> {
         self.write_primitive(primitive, region, Drawn::Yes);
     }
 
+    /// The next handle from the previous draw, if it can hold what is
+    /// about to be written: same kind of primitive, same layer, and the
+    /// same answer to "does a layer's draw order name it".
+    ///
+    /// **Consumed strictly in order, and one mismatch ends recycling for
+    /// the rest of the draw.** A widget's `draw` is a function of its own
+    /// state, so a redraw writes the same sequence of primitives in the
+    /// same order in the overwhelmingly common case; searching the
+    /// remainder for a match would turn an O(1) step into an O(primitives)
+    /// one to rescue a case that means the widget's content changed shape
+    /// anyway. Stopping is also what keeps the invariant simple: every
+    /// handle from `recycled` on is untouched and gets freed together.
+    fn take_recycled(&mut self, binding: u32, drawn: Drawn) -> Option<PrimitiveHandle> {
+        let h = self.recycle.peek()?;
+        let drawn_matches = (h.pos == NOT_DRAWN) == (drawn == Drawn::No);
+        if h.binding != binding || h.layer != self.layer || !drawn_matches {
+            // Left un-taken deliberately: this handle and everything after
+            // it is freed together when the draw ends.
+            return None;
+        }
+        self.recycle.next()
+    }
+
     /// The one path every primitive this widget owns goes through --
     /// drawn or, for a mask's shape, only referenced.
     fn write_primitive<P: Primitive>(
@@ -40,17 +74,20 @@ impl<'a> Painter<'a> {
         region: UiRegion,
         drawn: Drawn,
     ) -> u32 {
-        let h = self.state.write_primitive(
-            self.layer,
-            drawn,
-            PrimitiveInst {
-                id: self.id,
-                primitive,
-                region,
-                mask_idx: self.mask,
-                move_idx: self.move_slot,
-            },
-        );
+        let inst = PrimitiveInst {
+            id: self.id,
+            primitive,
+            region,
+            mask_idx: self.mask,
+            move_idx: self.move_slot,
+        };
+        let h = match self.take_recycled(P::BINDING, drawn) {
+            Some(h) => {
+                self.state.primitives.recycle(&h, inst);
+                h
+            }
+            None => self.state.write_primitive(self.layer, drawn, inst),
+        };
         if self.mask != MaskIdx::NONE {
             // TODO: I have no clue if this works at all :joy:
             self.rsc.ui_mut().masks.push_ref(self.mask);
@@ -209,9 +246,7 @@ impl<'a> Painter<'a> {
             Some(self.id),
             self.move_slot.idx() as u32,
             self.mask,
-            None,
-            None,
-            crate::render::MaskIdx::NONE,
+            Default::default(),
             self.rsc,
         );
         self.state
@@ -271,14 +306,27 @@ impl<'a> Painter<'a> {
     /// the layer's one instanced draw, so it goes through
     /// `Primitives::write_image` instead of `primitive_at`/`Primitive::vec`.
     fn write_image(&mut self, texture_idx: u32, region: UiRegion) {
-        let h = self.state.write_image(
-            self.layer,
-            self.id,
-            texture_idx,
-            region,
-            self.mask,
-            self.move_slot,
-        );
+        let h = match self.take_recycled(IMAGE_BINDING, Drawn::Yes) {
+            Some(h) => {
+                self.state.primitives.recycle_image(
+                    &h,
+                    self.id,
+                    texture_idx,
+                    region,
+                    self.mask,
+                    self.move_slot,
+                );
+                h
+            }
+            None => self.state.write_image(
+                self.layer,
+                self.id,
+                texture_idx,
+                region,
+                self.mask,
+                self.move_slot,
+            ),
+        };
         if self.mask != MaskIdx::NONE {
             self.rsc.ui_mut().masks.push_ref(self.mask);
         }