chore: decommission FMP, Finnhub and Alpha Vantage (A6)

The A5 cutover has been on and observed in production, so SEC Company Facts +
DoltHub earnings are already the live source for `fundamental_data`. This
removes everything the legacy path still occupied.

Gone: the three providers and their config/env keys; the weekly
`fundamental_collector` job; the cutover toggle (SEC + Dolt is now the
unconditional path, so `off` can no longer silently freeze scoring inputs); the
A5 parity report, whose deltas became structurally zero once the candidate
builder started writing the table it compared against; and the FMP tier of
universe bootstrap.

Two behavioral notes:

- Disabling **SEC Fundamentals Import** now stops the SEC network fetch only.
  The local cache refresh moved outside the job-enable check, because candidates
  also derive from daily closes and earnings events — freezing those on an
  ingestion pause would stale scoring with no fallback left to recover from.
- `/ingestion/fetch?sources=fundamentals` still accepts the key and reports
  `skipped`; there is no per-ticker fetch any more.

Migration 029 does not blanket-delete the leftover settings rows. Migrations run
before the service restart, and pre-A6 code reads an absent `job_*_enabled` row
as *enabled* — so the two behavior-bearing keys become tombstones pinned to safe
values (hidden in Admin) and only the inert three are deleted. Removing the
provider keys from the production `.env` is the matching rollout step.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/services/fundamental_service.py

@@ -1,22 +1,19 @@
-"""Fundamental data service.
+"""Fundamental data read access.
 
-Stores fundamental data (P/E, revenue growth, earnings surprise, market cap)
-and marks the fundamental dimension score as stale on new data.
+``fundamental_data`` is the compat cache scoring reads. It is written solely by
+``fundamental_data_refresh_service`` from SEC snapshots, Dolt earnings events and
+stored closes; nothing fetches it per ticker.
 """
 
 from __future__ import annotations
 
-import json
 import logging
-from datetime import datetime, timezone
 
-from sqlalchemy import select, update
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.database import insert_for_session
 from app.exceptions import NotFoundError
 from app.models.fundamental import FundamentalData
-from app.models.score import DimensionScore
 from app.models.ticker import Ticker
 
 logger = logging.getLogger(__name__)
@@ -32,65 +29,6 @@ async def _get_ticker(db: AsyncSession, symbol: str) -> Ticker:
     return ticker
 
 
-async def store_fundamental(
-    db: AsyncSession,
-    symbol: str,
-    pe_ratio: float | None = None,
-    revenue_growth: float | None = None,
-    earnings_surprise: float | None = None,
-    market_cap: float | None = None,
-    next_earnings_date=None,
-    unavailable_fields: dict[str, str] | None = None,
-) -> FundamentalData:
-    """Store or update fundamental data for a ticker.
-
-    Keeps a single latest snapshot per ticker. On new data, marks the
-    fundamental dimension score as stale (if one exists).
-    """
-    ticker = await _get_ticker(db, symbol)
-
-    now = datetime.now(timezone.utc)
-    unavailable_fields_json = json.dumps(unavailable_fields or {})
-
-    stmt = insert_for_session(db, FundamentalData).values(
-        ticker_id=ticker.id,
-        pe_ratio=pe_ratio,
-        revenue_growth=revenue_growth,
-        earnings_surprise=earnings_surprise,
-        market_cap=market_cap,
-        next_earnings_date=next_earnings_date,
-        fetched_at=now,
-        unavailable_fields_json=unavailable_fields_json,
-    )
-    stmt = stmt.on_conflict_do_update(
-        index_elements=["ticker_id"],
-        set_={
-            "pe_ratio": stmt.excluded.pe_ratio,
-            "revenue_growth": stmt.excluded.revenue_growth,
-            "earnings_surprise": stmt.excluded.earnings_surprise,
-            "market_cap": stmt.excluded.market_cap,
-            "next_earnings_date": stmt.excluded.next_earnings_date,
-            "fetched_at": stmt.excluded.fetched_at,
-            "unavailable_fields_json": stmt.excluded.unavailable_fields_json,
-        },
-    ).returning(FundamentalData)
-    record = (await db.execute(stmt)).scalar_one()
-
-    # Mark fundamental dimension score as stale if it exists
-    # TODO: Use DimensionScore service when built
-    await db.execute(
-        update(DimensionScore)
-        .where(
-            DimensionScore.ticker_id == ticker.id,
-            DimensionScore.dimension == "fundamental",
-        )
-        .values(is_stale=True)
-    )
-
-    await db.commit()
-    return record
-
-
 async def get_fundamental(
     db: AsyncSession,
     symbol: str,