Phase 5 Stage E: full kind migration into packages/nodes

Wholesale move of every remaining kind into its own subdirectory under
`packages/nodes/src/`, finishing the registry-driven migration. Each
kind now ships its definition, schema (re-exported from core), and any
of `geometry` / `renderer` / `system` / `floorplan` / `tool` /
`move-tool` / `panel` / `floorplan-move` / `floorplan-affordances` /
`parametrics` / `preview` it needs — no per-kind code remains under
`packages/editor/src/components/tools/` or
`packages/viewer/src/components/renderers/`.

Deleted (replaced by registry-driven equivalents):
- `tools/{ceiling,column,door,fence,item,slab,spawn,wall,window}/...`
  (boundary editors, hole editors, placement tools, move tools,
  endpoint movers, curve tools, helpers, math libs)
- `ui/helpers/{ceiling,slab,wall}-helper.tsx`
- `ui/panels/{column,door,elevator,item,roof,roof-segment,spawn,
  stair,stair-segment,wall,window}-panel.tsx`
- `viewer/src/components/renderers/{building,ceiling,column,door,
  elevator,fence,guide,item,level,roof,roof-segment,scan,site,slab,
  spawn,stair,stair-segment,wall,window,zone}-renderer.tsx`
- `viewer/src/components/viewer/legacy-system.tsx`

Added under `packages/nodes/src/`:
- `building/`, `column/`, `elevator/`, `guide/`, `level/`, `roof/`,
  `roof-segment/`, `scan/`, `shared/`, `site/`, `stair/`,
  `stair-segment/` packages with definition + schema + renderer / system
  / floorplan / panel as appropriate.
- New `floorplan-move.ts` for every kind that supports 2D moves
  (ceiling, door, item, shelf, slab, window) — single registry-driven
  dispatch path via `def.floorplanMoveTarget`.
- New `floorplan-affordances.ts` for kinds with polygon / endpoint
  drags (ceiling, fence, slab, wall) — using the shared
  `polygon-vertex-affordance` factories.
- New per-kind `panel.tsx` for kinds with custom inspector content
  (door, item, shelf, spawn, wall, window).
- New per-kind `tool.tsx` for placement (door, item, shelf, window).
- New per-kind `move-tool.tsx` for kinds with custom 3D move flows
  (door, item, slab, window).

Coordinator + manager updates in `packages/editor/`:
- `tool-manager.tsx` resolves tools from the registry only — no
  hardcoded type→component map.
- `panel-manager.tsx` resolves inspector panels the same way.
- `placement-{coordinator,strategies,types}.ts` extended with
  shelf-surface placement.
- `selection-manager.tsx` adds the registry-selectable fallback.
- `floorplan-panel.tsx`, `floorplan-background-placement.ts`,
  `floorplan-render-context.tsx` updated for the registry layer's new
  contract (props, affordance dispatch, render context).

Viewer updates:
- `viewer/index.tsx` drops legacy renderer mounts.
- `node-renderer.tsx` resolves by registry only.
- `scene-bvh.tsx`, `use-node-events.ts`, `level-system.tsx`,
  `wall-cutout.tsx`, `zone-system.tsx`, `materials.ts` adjusted for
  the registry-only world.

Sidebar tree nodes for ceiling / fence / slab / shelf / tree-node
updated to read from the registered nodes instead of the deleted
legacy renderer trees.

Wiki: new `plugin-authoring.md` page, README index updated.

Tests in `packages/nodes/src/index.test.ts` validate every registered
kind has the required shape.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/nodes/src/ceiling/floorplan.ts

@@ -1,15 +1,29 @@
-import type { CeilingNode, FloorplanGeometry, FloorplanPoint } from '@pascal-app/core'
+import type {
+  CeilingNode,
+  FloorplanGeometry,
+  FloorplanPoint,
+  GeometryContext,
+} from '@pascal-app/core'
 
 /**
- * Stage C floor-plan builder for ceiling. Renders the polygon outline
- * as a dashed boundary (ceilings are above and would visually obscure
- * the slab/walls if drawn solid). Same shape as slab but visually
- * distinct.
+ * Stage C floor-plan builder for ceiling. Dashed boundary (ceilings sit
+ * above the slab); when selected, mounts the same boundary editor as
+ * slab — vertex + midpoint + edge handles on the outer ring AND every
+ * hole, with `holeIndex` carried in the handle payloads.
  */
-export function buildCeilingFloorplan(node: CeilingNode): FloorplanGeometry | null {
+export function buildCeilingFloorplan(
+  node: CeilingNode,
+  ctx: GeometryContext,
+): FloorplanGeometry | null {
   const polygon = node.polygon
   if (!polygon || polygon.length < 3) return null
 
+  const view = ctx.viewState
+  const palette = view?.palette
+  const isSelected = view?.selected ?? false
+  const isHighlighted = view?.highlighted ?? false
+  const showSelectedChrome = isSelected || isHighlighted
+
   const outer: FloorplanPoint[] = polygon.map(([x, z]) => [x, z] as FloorplanPoint)
 
   const ring = (points: FloorplanPoint[]) => {
@@ -25,13 +39,71 @@ export function buildCeilingFloorplan(node: CeilingNode): FloorplanGeometry | nu
     segments.push(ring(hole.map(([x, z]) => [x, z] as FloorplanPoint)))
   }
 
-  return {
-    kind: 'path',
-    d: segments.join(' '),
-    fill: 'none',
-    stroke: '#94a3b8',
-    strokeWidth: 0.03,
-    strokeDasharray: '0.15 0.1',
-    opacity: 0.7,
+  const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#94a3b8'
+
+  const children: FloorplanGeometry[] = [
+    {
+      kind: 'path',
+      d: segments.join(' '),
+      fill: 'none',
+      stroke,
+      strokeWidth: showSelectedChrome ? 0.04 : 0.03,
+      strokeDasharray: '0.15 0.1',
+      opacity: showSelectedChrome ? 0.95 : 0.7,
+    },
+  ]
+
+  if (isSelected) {
+    appendRingEditor(children, polygon, undefined)
+    holes.forEach((hole, holeIndex) => {
+      if (hole.length >= 3) appendRingEditor(children, hole, holeIndex)
+    })
+  }
+
+  return { kind: 'group', children }
+}
+
+/**
+ * Same boundary editor as slab — see `nodes/src/slab/floorplan.ts` for
+ * the contract. The kinds differ only in their fill / stroke chrome;
+ * the editor primitives are identical.
+ */
+function appendRingEditor(
+  children: FloorplanGeometry[],
+  ring: ReadonlyArray<readonly [number, number]>,
+  holeIndex: number | undefined,
+): void {
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i]!
+    const b = ring[(i + 1) % ring.length]!
+    children.push({
+      kind: 'edge-handle',
+      x1: a[0],
+      y1: a[1],
+      x2: b[0],
+      y2: b[1],
+      affordance: 'move-edge',
+      payload: { holeIndex, edgeIndex: i },
+    })
+  }
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i]!
+    const b = ring[(i + 1) % ring.length]!
+    children.push({
+      kind: 'midpoint-handle',
+      point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+      affordance: 'add-vertex',
+      payload: { holeIndex, edgeIndex: i },
+    })
+  }
+  for (let i = 0; i < ring.length; i++) {
+    const [x, z] = ring[i]!
+    children.push({
+      kind: 'endpoint-handle',
+      point: [x, z],
+      state: 'idle',
+      affordance: 'move-vertex',
+      payload: { holeIndex, vertexIndex: i },
+    })
   }
 }