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/scan/definition.ts

@@ -0,0 +1,50 @@
+import { type NodeDefinition, ScanNode as ScanNodeSchema } from '@pascal-app/core'
+import { scanParametrics } from './parametrics'
+import { ScanNode } from './schema'
+
+/**
+ * Scan — Stage A. Mesh imported from the capture pipeline (LiDAR /
+ * photogrammetry). `ScanSystem` handles mesh loading + per-frame
+ * positioning; renderer mounts the imported geometry.
+ */
+export const scanDefinition: NodeDefinition<typeof ScanNode> = {
+  kind: 'scan',
+  schemaVersion: 1,
+  schema: ScanNode,
+  category: 'site',
+
+  defaults: () => {
+    const stub = ScanNodeSchema.parse({ id: 'scan_default' as never, type: 'scan' })
+    const { id: _id, type: _type, ...rest } = stub
+    return rest
+  },
+
+  capabilities: {
+    selectable: { hitVolume: 'bbox' },
+    duplicable: false,
+    deletable: true,
+  },
+
+  parametrics: scanParametrics,
+
+  renderer: {
+    kind: 'parametric',
+    module: () => import('./renderer'),
+  },
+  system: {
+    module: () => import('./system'),
+    priority: 1,
+  },
+
+  presentation: {
+    label: 'Scan',
+    description: 'A captured mesh (LiDAR / photogrammetry) imported as a scene reference.',
+    icon: { kind: 'url', src: '/icons/mesh.png' },
+    paletteSection: 'site',
+    paletteOrder: 40,
+  },
+
+  mcp: {
+    description: 'A captured mesh import.',
+  },
+}

packages/nodes/src/scan/index.ts

@@ -0,0 +1 @@
+export { scanDefinition } from './definition'

packages/nodes/src/scan/parametrics.ts

@@ -0,0 +1,5 @@
+import type { ParametricDescriptor, ScanNode } from '@pascal-app/core'
+
+export const scanParametrics: ParametricDescriptor<ScanNode> = {
+  groups: [],
+}

packages/nodes/src/scan/renderer.tsx

@@ -0,0 +1,79 @@
+'use client'
+
+import { type ScanNode, useRegistry } from '@pascal-app/core'
+import { useAssetUrl, useGLTFKTX2, useViewer } from '@pascal-app/viewer'
+import { Suspense, useMemo, useRef } from 'react'
+import type { Group, Material, Mesh } from 'three'
+
+export const ScanRenderer = ({ node }: { node: ScanNode }) => {
+  const showScans = useViewer((s) => s.showScans)
+  const ref = useRef<Group>(null!)
+  useRegistry(node.id, 'scan', ref)
+
+  const resolvedUrl = useAssetUrl(node.url)
+
+  return (
+    <group
+      position={node.position}
+      ref={ref}
+      rotation={node.rotation}
+      scale={[node.scale, node.scale, node.scale]}
+      visible={showScans}
+    >
+      {resolvedUrl && (
+        <Suspense>
+          <ScanModel opacity={node.opacity} url={resolvedUrl} />
+        </Suspense>
+      )}
+    </group>
+  )
+}
+
+const ScanModel = ({ url, opacity }: { url: string; opacity: number }) => {
+  const gltf = useGLTFKTX2(url) as any
+  const scene = gltf.scene
+
+  useMemo(() => {
+    const normalizedOpacity = opacity / 100
+    const isTransparent = normalizedOpacity < 1
+
+    const updateMaterial = (material: Material) => {
+      if (isTransparent) {
+        material.transparent = true
+        material.opacity = normalizedOpacity
+        material.depthWrite = false
+      } else {
+        material.transparent = false
+        material.opacity = 1
+        material.depthWrite = true
+      }
+      material.needsUpdate = true
+    }
+
+    scene.traverse((child: any) => {
+      if ((child as Mesh).isMesh) {
+        const mesh = child as Mesh
+
+        // Disable raycasting
+        mesh.raycast = () => {}
+
+        // Exclude from bounding box calculations
+        mesh.geometry.boundingBox = null
+        mesh.geometry.boundingSphere = null
+        mesh.frustumCulled = false
+
+        if (Array.isArray(mesh.material)) {
+          mesh.material.forEach((material) => {
+            updateMaterial(material)
+          })
+        } else {
+          updateMaterial(mesh.material)
+        }
+      }
+    })
+  }, [scene, opacity])
+
+  return <primitive object={scene} />
+}
+
+export default ScanRenderer

packages/nodes/src/scan/schema.ts

@@ -0,0 +1 @@
+export { ScanNode } from '@pascal-app/core'

packages/nodes/src/scan/system.tsx

@@ -0,0 +1,5 @@
+'use client'
+
+import { ScanSystem } from '@pascal-app/viewer'
+
+export default ScanSystem