feat(3-J): enrichment framework + GeocoderEnricher + NoOpBackend + FIRMS pilot

First of three PRs for v0.5.0 (J: framework; K: real geocoder backends +
doc revisions; L: operator events tab + per-adapter render + events-map fix).

Design pivot: the Phase 2 "no enrichment, upstream verbatim" reading of
Matt's principle is reframed — consumers can't do follow-up lookups, they
only see what's on the wire, so whatever Central doesn't enrich is
effectively missing downstream. Enrichment is now expected. The producer-doc
§2/§10.1 rewrite lands in PR K; this PR builds the framework PR K documents.

New package src/central/enrichment/:
- base.py        Enricher Protocol (name + async enrich(location) -> dict).
- geocoder.py    GeocoderEnricher + GeocoderBackend Protocol + the locked
                 GEOCODER_FIELDS set (name, city, county, state, country,
                 postal_code, timezone, landclass, elevation_m) + all_null_bundle().
- cache.py       EnrichmentCache — stdlib sqlite3 off the event loop via
                 asyncio.to_thread (no async-sqlite dep). Keyed on
                 (enricher_name, lat_4dp, lon_4dp); per-enricher TTL (24h
                 default); fresh connection per op (sqlite3 isn't thread-safe
                 to share). Cache even all-null; never cache backend failures.
- backends/no_op.py  NoOpBackend — all-null bundle, the PR J default.

Provenance: enrichment results land under event.data["_enriched"][<name>];
everything else in data stays upstream verbatim.

Wiring:
- adapter.py        enrichment_locations: list[tuple[str,str]] = [] class attr.
                    Empty (default) = publish as-is, no enrichment.
- config_models.py  EnrichmentConfig (enricher_class, backend_class,
                    backend_settings, cache_ttl_s). Read once at startup.
- supervisor.py     build_enrichers() + apply_enrichment(); enrichment runs
                    after dedup, before wrap_event, in the poll loop. Class-name
                    registries for enricher/backend resolution (PR K extends).
- firms.py          enrichment_locations = [("latitude","longitude")] — pilot.

Enrichment config is read once at supervisor startup; hot-reload is out of
scope for PR J (noted in EnrichmentConfig + build_enrichers docstrings).

Tests (16 new):
- test_enrichment_framework.py (9): parent-dir/table init, cache miss->hit,
  TTL expiry, 4dp rounding, nearby-coord collapse, concurrent-set single-row,
  backend-failure all-null-not-cached (retries), success cached (one backend
  call), all-null cached.
- test_geocoder_enricher.py (5): NoOp all-null, field-set == GEOCODER_FIELDS,
  null-coords short-circuit (no backend call), name=="geocoder", sequential
  same-coords single backend call.
- test_firms.py (+2): enrichment_locations declared + paths resolve to floats
  in a real event (structural, not literal); event through supervisor
  apply_enrichment emerges with data._enriched.geocoder == all-null bundle.

Verification: full pytest 495 passed (was 479; +16). grep for
subject_for_event/_ADAPTER_REGISTRY clean. Module imports cleanly.

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

tests/test_firms.py

@@ -421,3 +421,58 @@ class TestApplyConfig:
         assert adapter._satellites == ["VIIRS_NOAA20_NRT"]
 
         await adapter.shutdown()
+
+
+class TestEnrichmentIntegration:
+    """FIRMS is the PR J enrichment pilot."""
+
+    def test_enrichment_locations_declared_and_resolvable(self, temp_db_path, mock_config_store):
+        """FIRMS declares enrichment_locations and the declared paths actually
+        resolve to coordinates in a real event's data — verified structurally,
+        not by hardcoding the literal tuple."""
+        locations = getattr(FIRMSAdapter, "enrichment_locations")
+        assert isinstance(locations, list) and len(locations) >= 1
+        for tup in locations:
+            assert isinstance(tup, tuple) and len(tup) == 2
+            assert all(isinstance(p, str) for p in tup)
+
+        config = make_adapter_config()
+        adapter = FIRMSAdapter(
+            config=config,
+            config_store=mock_config_store,
+            cursor_db_path=temp_db_path,
+        )
+        rows = adapter._parse_csv(SAMPLE_CSV, "VIIRS_SNPP_NRT")
+        event = adapter._row_to_event(rows[0], "VIIRS_SNPP_NRT")
+        # Every declared (lat_path, lon_path) must resolve to a float in data.
+        for lat_path, lon_path in locations:
+            assert isinstance(event.data.get(lat_path), float)
+            assert isinstance(event.data.get(lon_path), float)
+
+    @pytest.mark.asyncio
+    async def test_event_passes_through_supervisor_enrichment(
+        self, tmp_path, temp_db_path, mock_config_store
+    ):
+        """A FIRMS event run through the supervisor's enrichment stage emerges
+        with data._enriched.geocoder populated (all-null under NoOpBackend)."""
+        from central.config_models import EnrichmentConfig
+        from central.enrichment.geocoder import all_null_bundle
+        from central.supervisor import apply_enrichment, build_enrichers
+
+        config = make_adapter_config()
+        adapter = FIRMSAdapter(
+            config=config,
+            config_store=mock_config_store,
+            cursor_db_path=temp_db_path,
+        )
+        rows = adapter._parse_csv(SAMPLE_CSV, "VIIRS_SNPP_NRT")
+        event = adapter._row_to_event(rows[0], "VIIRS_SNPP_NRT")
+        assert "_enriched" not in event.data
+
+        enrichers = build_enrichers(
+            EnrichmentConfig(), cache_db_path=tmp_path / "enrichment_cache.db"
+        )
+        await apply_enrichment(event, adapter.enrichment_locations, enrichers)
+
+        assert "_enriched" in event.data
+        assert event.data["_enriched"]["geocoder"] == all_null_bundle()