Colliders take a frame's outline and tiles have their own surface (#193)

Issue #193 asked where friction, bounciness and density of a tile
live. Tiles had a fixed surface (friction 0.5, bounciness 0) and a
collider could not use the outline drawn on a texture frame (#141).
Both gaps are closed here.

- A collider has a fifth shape "Frame collision" with a Frame row.
  The frame is picked like a sprite's texture and stored as the
  value 'frame'.
- The shape is linked, not copied. Redrawing the outline in the
  texture tab changes every collider using that frame, in the editor
  and on the next play.
- The frame centre sits on the collider origin, one image pixel is
  one unit. The shape turns, scales and mirrors like any other.
- Every outline ring blocks. Each ring is split into convex parts the
  same way a polygon is.
- Without a frame, with a whole texture or with a frame that has no
  outline, the collider is drawn red as a box and blocks nothing.
- Move, Rapier, raycast, detection, hit test, drawing and footprint
  all resolve the frame. At runtime an entity looks the frame up
  live in the current project.
- A tile has Friction and Bounciness next to Solid and One-way. The
  rows only show when Solid is on. Defaults and mixing rules match
  the collider. Density is left out because a tilemap never moves.
- Tilemap cells are grouped by surface as well as by one-way angle.
  Ice and stone never merge into one rectangle, and every cell brings
  its surface to Move and Rapier.

Findings:

- A tile with a collision scale below 1 is no longer flush with a
  neighbour of another surface. It is inset there like at an open
  side, the same as next to one-way tiles today.
- A bounce test first measured 0.84. The ball had landed on the hero
  at the origin, not on the tile. On the tile it measures 0.993.

Tests:

- ./check.sh: 130 files, 1931 tests, exit 0 (was 129 / 1917).
- 14 new unit tests in tests/core/surface.test.ts. The Move tests run
  against the editor run and the physics system.
- 3 new e2e checks: 40l (surface rows follow Solid), 42e (collider
  has frame size, a walker climbs the slope in the frame).
- GM_STEPS=1-8,39-43 freshly seeded: ALL PASSED, 376 checks.
- Three counter-probes bite: Move ignores the tile surface (2 fail),
  Rapier ignores it (1 fails), frame shape falls back to a box
  (5 fail).
- Check sum 1198 is computed (1195 + 3), the full run belongs to CI.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/properties/bounds.ts

@@ -4,6 +4,7 @@
  * where its corners are.
  */
 import { type AssetType, hasSceneIcon } from '../model/AssetTypes';
+import type { FrameOutline } from '../model/frameOutline';
 import {
   apply,
   boxCorners,
@@ -49,15 +50,22 @@ export function textAnchor(props: PropertyBag): number {
   return align === 'left' ? 0 : align === 'right' ? 1 : 0.5;
 }
 
-/** Centred on the object's position; text is anchored instead (see `textAnchor`). */
-export function footprintOf(type: AssetType, props: PropertyBag): { w: number; h: number } {
+/**
+ * Centred on the object's position; text is anchored instead (see `textAnchor`). A collider that
+ * wears a frame (#193) is that frame's size, which only the caller can look up.
+ */
+export function footprintOf(
+  type: AssetType,
+  props: PropertyBag,
+  frame?: FrameOutline | null,
+): { w: number; h: number } {
   switch (type) {
     case 'sprite':
       return { w: Number(props.width ?? 1), h: Number(props.height ?? 1) };
     case 'text':
       return textSize(props);
     case 'collider':
-      return colliderSize(props);
+      return colliderSize(props, frame);
     case 'behavior':
       return { w: BEHAVIOR_SYMBOL, h: BEHAVIOR_SYMBOL };
     case 'container':
@@ -93,16 +101,27 @@ function anchorOffset(type: AssetType, props: PropertyBag, w: number): number {
 }
 
 /** The footprint's corners in world units, grown by `pad` world units on every side. */
-export function footprintCorners(type: AssetType, props: PropertyBag, m: Mat, pad = 0): Vec2[] {
+export function footprintCorners(
+  type: AssetType,
+  props: PropertyBag,
+  m: Mat,
+  pad = 0,
+  frame?: FrameOutline | null,
+): Vec2[] {
   const placed = placementOf(type, m);
-  const { w, h } = footprintOf(type, props);
+  const { w, h } = footprintOf(type, props, frame);
   const local = pad / (scaleOf(placed) || 1);
   return boxCorners(placed, w + 2 * local, h + 2 * local, anchorOffset(type, props, w), 0);
 }
 
 /** The world rectangle around the drawn footprint – what culling, framing and labels need. */
-export function footprintExtent(type: AssetType, props: PropertyBag, m: Mat): Extent {
-  return extentOfPoints(footprintCorners(type, props, m));
+export function footprintExtent(
+  type: AssetType,
+  props: PropertyBag,
+  m: Mat,
+  frame?: FrameOutline | null,
+): Extent {
+  return extentOfPoints(footprintCorners(type, props, m, 0, frame));
 }
 
 export function footprintContains(type: AssetType, props: PropertyBag, m: Mat, point: Vec2): boolean {