Draw each primitive with its own pipeline, registered rather than declared

The `primitives!` macro, `PrimitiveData`, `PrimitiveVec`,
`PrimitiveBuffers`, the `Primitive` trait and the shader's dispatch
switch are gone. A primitive is now a registration: its WGSL and,
implicitly, the size of the entry that WGSL reads. Everything else --
its instance list, its free list, its buffers, its bind group and its
pipeline -- follows from that, so adding one is a `register` call and a
shader file, with nothing per-type to remember and no cross-type
dispatch to extend.

Nothing dispatches dynamically. Push, free, renumber, upload and draw
are identical for every primitive; what differs is the entry size and
the pipeline, which are data. So `InstanceList` carries a runtime
stride and its instances' data as bytes, and one concrete type serves
every primitive and the textures. Measured against a typed list it
costs 0.2ns per write, where a trait object costs 1.6ns.

Because each type has its own list, an instance's index is also its
data index: `@builtin(instance_index)` replaces the `idx` field, the
`binding` field goes with the switch, and `PrimitiveInstance` drops from
28 bytes to 20. `PrimitiveVec`'s free list merges into the instance
list's, so an instance and its data are freed by one `swap_remove`
rather than two arenas kept in step.

`shader.wgsl` becomes `shader/prelude.wgsl` plus one file per primitive.
The prelude carries the window, masks, sampled texture, vertex shader
and `masked()`, and is compiled ahead of each primitive's own source --
which is also what a caller's own primitive would be. Masks move back
into group 0 beside the window uniform, since every pipeline shares one
layout.

Within a layer, types now draw in registration order: a rect under a
glyph under a texture. Order within a layer was never meaningful --
freeing an instance swaps another into its place -- so this replaces an
accident with a defined order, and backgrounds land under their content.

Verified with a headless run per case: text over its own rect and an
image over its own rect in one layer, a masked stack clipping, the
text-layout tab, and adding three images and deleting one.

core/src/primitive/layer.rs

@@ -2,7 +2,7 @@ use std::ops::{Index, IndexMut};
 
 use crate::{
     UiRegion, WidgetId,
-    render::{LayerDraws, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    render::{LayerDraws, MaskIdx, PrimitiveHandle, PrimitiveKind},
     util::to_mut,
 };
 
@@ -121,12 +121,16 @@ impl<T: Default> Layers<T> {
 }
 
 impl DrawLayers {
-    pub fn write<P: Primitive>(
+    pub fn write<P: bytemuck::Pod>(
         &mut self,
         layer: LayerId,
-        info: PrimitiveInst<P>,
+        kind: PrimitiveKind<P>,
+        id: WidgetId,
+        primitive: P,
+        region: UiRegion,
+        mask_idx: MaskIdx,
     ) -> PrimitiveHandle {
-        self[layer].write(layer, info)
+        self[layer].write(layer, kind, id, primitive, region, mask_idx)
     }
 
     pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {