Take pointer input through one dispatcher per scene

Every layer and tool bound its own ScreenSpaceEventHandler and picked the
same click again: with the usual layers on, one click ran about 26
scene.pick and 2 drillPick passes (120-215 ms in NYC with 18 layers). Pointer
input now comes in through src/input/dispatcher.js, one handler per scene.
A click is picked lazily and at most once per kind of query, and every
subscriber reads the same ClickEvent (pick, hit, id, ownerId, gesture,
drill, ground). The same click now costs 3 picks and 2 drills, 17-70 ms.

- Ambient onClick subscribers run only while no tool holds the pointer,
  checked once per event; tools subscribe with their lease. Moves and
  releases always reach ambient subscribers, so hover and drags end cleanly.
- Camera input and the viewer's stock select/track clicks are ref-counted
  holds (suspendCamera, suppressStockClicks). The dispatcher owns the
  controller's enableInputs, so a Cesium flight that ends no longer turns
  input back on under a drag or the cockpit.
- The draw tool, imagery box, CCTV gizmo, cockpit, directions and every
  selecting layer use it; bindTrackingClickGesture is gone (the gesture is
  on the event). A source scan forbids new handlers, enableInputs writes and
  stock-click removal outside the dispatcher.
- The sensor-style pick correction transit had now applies to every layer.
- Radio's 8-pick near-miss ring is one 17x17 windowed drill.
- A missed pick passed to pickContact is no longer picked again, and a
  touch tap's contact search shares the click's drill.
- A gizmo drag whose release Cesium never reported ends on the next press
  instead of leaving the camera held.

The dispatcher is exported as ./input with the pointer-lease functions, and
documented in docs/APPLICATION.md.

docs/APPLICATION.md

@@ -81,6 +81,56 @@ constructed component objects; the component instances themselves remain mutable
 `ready` means all constructors have returned. Background feed activity and the
 standalone share-restoration result keep their existing separate contracts.
 
+## Pointer input
+
+`gods-eye-view/input` exports `inputFor(viewer)`, the scene's one input
+dispatcher. Every layer and tool takes its pointer input from it, and so can
+the caller: one `ScreenSpaceEventHandler` per scene, and a click picked once
+and handed to every subscriber.
+
+```js
+import { inputFor } from 'gods-eye-view/input';
+
+const input = inputFor(viewer);
+const off = input.onClick((event) => {
+  if (event.ownerId === 'flights') showFlight(event.id);
+});
+// Later:
+off();
+```
+
+`onClick` runs while no tool holds the pointer (the draw tool, the imagery
+box), so a vertex placed on an aircraft is not also a click on it. Its event
+reads lazily; a subscriber that reads nothing costs no pick:
+
+| Member             | What it is                                                           |
+| ------------------ | -------------------------------------------------------------------- |
+| `screenPosition`   | Where the user clicked, in CSS pixels; for DOM and overlay hit-tests |
+| `position`         | Where that lands in the pick buffer (corrected under sensor styles)  |
+| `gesture`          | `{ travelPx, durationMs }` of the press, to tell a click from a drag |
+| `pick`             | `scene.pick` at `position`                                           |
+| `hit`              | `pick`, or on a coarse pointer the contact under a surface pick      |
+| `id`, `ownerId`    | The hit's pick id and the layer that registered it, or `null`        |
+| `meta`             | The hit's own metadata, when its pick carries any                    |
+| `surface`          | Whether the hit is the map itself                                    |
+| `drill(limit)`     | `scene.drillPick`, shared by every subscriber of the click           |
+| `pickWindow(w, h)` | `scene.pick` over a `w`×`h` window around `position`                 |
+| `ground()`         | The world position under the click, or `null` over the sky           |
+
+`onPointer(type, fn, { lease })` subscribes to `down`, `move`, `up`, `click`
+or `dblclick`; with a lease it runs only while that lease is current. A tool
+takes its lease with `claimPointer(ownerId)` from the same export (and gives
+it back with `releasePointer(lease)`), which also keeps every ambient
+subscriber off its clicks; `isPointerFree()` and `pointerOwner()` report who
+holds it. `suspendCamera(reason)` and `suppressStockClicks()` return their
+own release: camera input and the viewer's stock select and double-click-track
+come back when the last hold is released, so two holders cannot undo each
+other. The dispatcher owns the camera controller's `enableInputs`: a direct
+write (Cesium's camera flights make one when they start and end) is kept, but
+reads true only while no hold is out. A caller-supplied `createScene` that creates its own viewer registers
+`defer(() => inputFor(viewer).destroy())` right after it; the standalone scene
+does this and returns the dispatcher as `scene.input`.
+
 ## Standalone wiring
 
 `src/main.js` reads the existing browser configuration and starts