feat(street-level): Google Street View as the second imagery provider

Google Street View registers beside Mapillary as provider `google`. It runs
on the Maps JavaScript API with the browser GOOGLE_MAPS_API_KEY, loaded on
first use (mapsLoader.js), and uses Google's own StreetViewPanorama as its
viewer adapter, emitting provider-neutral poses (address and month in the
caption, a link to Google Maps, steps along Google's arrows, FOLLOW on
Google 3D). Its chip starts off because every panorama is billed to the
key; the share option is `g`.

Google offers no coverage layer for other maps, so the provider draws
none: with it on, a click on bare ground at street zoom opens its nearest
Google-collected outdoor panorama (groundClick.js). A key Google refuses
reads KEY REJECTED and fails a pending open at once; a lookup Google never
answers fails after 10 s.

Core: providers may declare `groundClick` and `defaultOn`; poses may carry
`capturedAtPrecision` and `title`; the coverage line keeps every
provider's hint; opening one provider's image releases another's
prewarmed viewer; FIT/FILL hides for viewers without render modes. CSP
script-src admits https://maps.googleapis.com. The browser gate gains two
Street View steps (the keyed one skips as 'no Google key' in CI).

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/layers/streetLevel/groundClick.test.mjs

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import * as Cesium from 'cesium';
+import { createGroundClick } from './groundClick.js';
+import { isPickedWorldPosition } from '../../data/scenePick.js';
+
+const GROUND = Cesium.Cartesian3.fromDegrees(-121.4944, 38.5816, 10);
+
+/** A layer state with providers `{id, on, groundClick, configured}` and a camera `height` m up. */
+function harness({
+  providers = [
+    { id: 'mapillary', groundClick: false },
+    { id: 'google', groundClick: true },
+  ],
+  height = 400,
+  enabled = true,
+  picked = GROUND,
+} = {}) {
+  const opened = [];
+  const state = {
+    enabled,
+    services: { scenePick: { isPickedWorldPosition } },
+    providers: new Map(
+      providers.map(({ id, on = true, groundClick, configured = true }) => [
+        id,
+        {
+          on,
+          def: { id, groundClick },
+          status: { configured },
+        },
+      ]),
+    ),
+    viewer: {
+      scene: {
+        pickPositionSupported: true,
+        pickPosition: () => picked,
+        globe: { getHeight: () => 10 },
+      },
+      camera: {
+        positionCartographic: Cesium.Cartographic.fromDegrees(
+          -121.4944,
+          38.5816,
+          10 + height,
+        ),
+        pickEllipsoid: () => undefined,
+      },
+    },
+  };
+  const openAtGround = createGroundClick({
+    state,
+    parts: {},
+    openNearest: (point, options) => {
+      opened.push({ point, options });
+      return Promise.resolve(true);
+    },
+  });
+  return { state, opened, openAtGround };
+}
+
+test('a ground click at street zoom opens the nearest image of the click-to-open providers there', () => {
+  const { opened, openAtGround } = harness();
+  openAtGround({ x: 10, y: 20 });
+  assert.equal(opened.length, 1);
+  const [{ point, options }] = opened;
+  assert.ok(Math.abs(point.lon - -121.4944) < 1e-9);
+  assert.ok(Math.abs(point.lat - 38.5816) < 1e-9);
+  assert.deepEqual(options, { providerIds: ['google'] });
+});
+
+test('nothing opens from high up, over the sky, with the provider off or unconfigured, or the layer off', () => {
+  for (const options of [
+    { height: 5000 },
+    { picked: null },
+    { picked: new Cesium.Cartesian3(500, 0, 0) },
+    { providers: [{ id: 'google', groundClick: true, on: false }] },
+    { providers: [{ id: 'google', groundClick: true, configured: false }] },
+    { providers: [{ id: 'mapillary', groundClick: false }] },
+    { enabled: false },
+  ]) {
+    const { opened, openAtGround } = harness(options);
+    assert.equal(openAtGround({ x: 1, y: 1 }), false, JSON.stringify(options));
+    assert.equal(opened.length, 0);
+  }
+});