refactor(street-level): drop hover, legend and byte-budget cache; flatten the provider directory

- No pointer cursor over coverage lines (no other layer has one); a click
  test replaces the hover tests.
- No legend: one source, one colour.
- The on-globe credit lives in index.js; credits.js is gone.
- Billboard glyphs are SVG data URLs with the same geometry, so tests need
  no canvas stub.
- The tile cache keeps the 120 most recently used tiles, same 24 h TTL,
  instead of a byte budget; listTileLayers was test-only.
- providers/mapillary/ is flattened into the layer and its policy merged
  into one policy.js; the source's method list is a literal in the catalog.
- One fakeCesiumViewer for the layer tests.
- The fixture gate keeps the steps the unit tests do not cover: coverage and
  credit, a rejected key, line -> cone -> photo, close, a keyless page.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

src/testSupport/streetLevelFakes.mjs

@@ -1,4 +1,4 @@
-/** Shared Street Level test stand-ins: Mapillary source, photo viewer, ray-casting camera. */
+/** Shared Street Level test stand-ins: Mapillary source, photo viewer, Cesium viewer, ray-casting camera. */
 import * as Cesium from 'cesium';
 
 const RAD = Math.PI / 180;
@@ -48,6 +48,87 @@ export function fakePhotoViewer({ pose = null } = {}) {
   };
 }
 
+/**
+ * A stand-in Cesium viewer a layer can be enabled on: a canvas for the click
+ * handler, camera events with Cesium's flight bookkeeping (`flights` counts
+ * them, lists them and can `land` the current one), primitive lists and a
+ * credit display. With `view`, the camera looks straight down on Sacramento
+ * from 900 m, so coverage asks for tiles.
+ */
+export function fakeCesiumViewer({ view = false } = {}) {
+  const credits = [];
+  let flight = null;
+  const flights = {
+    started: 0,
+    cancelled: 0,
+    /** Every flight asked for, oldest first: `{ sphere, options }`. */
+    list: [],
+    land() {
+      const current = flight;
+      flight = null;
+      current?.options.complete?.();
+    },
+  };
+  const stopFlight = () => {
+    const current = flight;
+    flight = null;
+    current?.options.cancel?.();
+    return Boolean(current);
+  };
+  const canvas = Object.assign(new EventTarget(), {
+    style: {},
+    // Keep Cesium's handler on the canvas; there is no real document here.
+    disableRootEvents: true,
+    onwheel: null,
+    ...(view ? { clientWidth: 100, clientHeight: 100 } : {}),
+  });
+  const camera = Object.assign(
+    view
+      ? rayCamera({
+          lon: -121.4944,
+          lat: 38.5816,
+          altitude: 900,
+          pitch: -90,
+          width: 100,
+          height: 100,
+        })
+      : {},
+    {
+      changed: new Cesium.Event(),
+      moveStart: new Cesium.Event(),
+      moveEnd: new Cesium.Event(),
+      flyToBoundingSphere(sphere, options = {}) {
+        stopFlight();
+        flight = { sphere, options };
+        flights.list.push(flight);
+        flights.started++;
+      },
+      cancelFlight() {
+        if (stopFlight()) flights.cancelled++;
+      },
+    },
+  );
+  return {
+    credits,
+    flights,
+    scene: {
+      canvas,
+      primitives: { add: (p) => p, remove() {} },
+      groundPrimitives: { add: (p) => p, remove() {} },
+      // Enough of a scene for the position marker to clamp to the ground.
+      frameState: { mode: Cesium.SceneMode.SCENE3D },
+      updateHeight: () => () => {},
+      getHeight: () => undefined,
+    },
+    camera,
+    creditDisplay: {
+      addStaticCredit: (credit) => credits.push(credit),
+      removeStaticCredit: (credit) =>
+        credits.splice(credits.indexOf(credit), 1),
+    },
+  };
+}
+
 /**
  * A pinhole camera `altitude` m above WGS84, at `heading` (deg from north) and
  * `pitch` (deg, negative down); `pickEllipsoid` hits whatever ellipsoid it gets.