refactor: dedupe scheduler logging/runtime, centralize SystemSetting access, fix rankings N+1

Behavior-preserving cleanup (345 tests pass, ruff clean):

- scheduler: replace 62 inline logger.x(json.dumps({...})) calls with a
  _log_event helper, and collapse 11 identical _job_runtime dicts into an
  _idle_runtime() factory over _JOB_NAMES.
- settings: add app/services/settings_store.py (get_setting/get_value/get_map/
  upsert_setting) and route ~13 hand-rolled SystemSetting queries + two
  identical _settings_map helpers through it.
- scoring.get_rankings: collapse the per-ticker N+1 (3-4 queries + a commit each)
  into 2 bulk reads + a single conditional commit; drop the redundant re-fetch.
  Lazy recompute-on-read is preserved. Adds first tests for get_rankings.

Net ~ -245 lines across the touched modules.

app/services/scoring_service.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import logging
+from collections import defaultdict
 from datetime import datetime, timezone
 
 from sqlalchemy import select
@@ -17,8 +18,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.exceptions import NotFoundError, ValidationError
 from app.models.score import CompositeScore, DimensionScore
-from app.models.settings import SystemSetting
 from app.models.ticker import Ticker
+from app.services import settings_store
 
 logger = logging.getLogger(__name__)
 
@@ -50,10 +51,7 @@ async def _get_ticker(db: AsyncSession, symbol: str) -> Ticker:
 
 async def _get_weights(db: AsyncSession) -> dict[str, float]:
     """Load scoring weights from SystemSetting, falling back to defaults."""
-    result = await db.execute(
-        select(SystemSetting).where(SystemSetting.key == SCORING_WEIGHTS_KEY)
-    )
-    setting = result.scalar_one_or_none()
+    setting = await settings_store.get_setting(db, SCORING_WEIGHTS_KEY)
     if setting is not None:
         try:
             return json.loads(setting.value)
@@ -64,21 +62,7 @@ async def _get_weights(db: AsyncSession) -> dict[str, float]:
 
 async def _save_weights(db: AsyncSession, weights: dict[str, float]) -> None:
     """Persist scoring weights to SystemSetting."""
-    result = await db.execute(
-        select(SystemSetting).where(SystemSetting.key == SCORING_WEIGHTS_KEY)
-    )
-    setting = result.scalar_one_or_none()
-    now = datetime.now(timezone.utc)
-    if setting is not None:
-        setting.value = json.dumps(weights)
-        setting.updated_at = now
-    else:
-        setting = SystemSetting(
-            key=SCORING_WEIGHTS_KEY,
-            value=json.dumps(weights),
-            updated_at=now,
-        )
-        db.add(setting)
+    await settings_store.upsert_setting(db, SCORING_WEIGHTS_KEY, json.dumps(weights))
 
 
 # ---------------------------------------------------------------------------
@@ -875,73 +859,62 @@ async def get_rankings(db: AsyncSession) -> dict:
     Returns dict suitable for RankingResponse.
     """
     weights = await _get_weights(db)
+    tickers = (await db.execute(select(Ticker).order_by(Ticker.symbol))).scalars().all()
 
-    # Get all tickers
-    result = await db.execute(select(Ticker).order_by(Ticker.symbol))
-    tickers = list(result.scalars().all())
-
-    rankings: list[dict] = []
-    for ticker in tickers:
-        # Get composite score
-        comp_result = await db.execute(
-            select(CompositeScore).where(CompositeScore.ticker_id == ticker.id)
+    async def _load_scores() -> tuple[dict[int, CompositeScore], dict[int, dict[str, DimensionScore]]]:
+        comps = {
+            c.ticker_id: c
+            for c in (await db.execute(select(CompositeScore))).scalars().all()
+        }
+        dims: dict[int, dict[str, DimensionScore]] = defaultdict(dict)
+        rows = await db.execute(
+            select(DimensionScore).order_by(DimensionScore.ticker_id, DimensionScore.id)
         )
-        comp = comp_result.scalar_one_or_none()
+        for ds in rows.scalars().all():
+            dims[ds.ticker_id][ds.dimension] = ds
+        return comps, dims
 
-        # If no composite or stale, recompute
+    # Two bulk reads instead of ~4 queries per ticker.
+    comps, dims_by_ticker = await _load_scores()
+
+    # Lazily recompute any stale/missing scores (kept fresh by the daily scan;
+    # this self-heals tickers that aged out between scans), committing once.
+    recomputed = False
+    for ticker in tickers:
+        comp = comps.get(ticker.id)
         if comp is None or comp.is_stale:
-            # Recompute stale dimensions first
-            dim_result = await db.execute(
-                select(DimensionScore).where(
-                    DimensionScore.ticker_id == ticker.id
-                )
-            )
-            dim_scores = {ds.dimension: ds for ds in dim_result.scalars().all()}
+            dim_scores = dims_by_ticker.get(ticker.id, {})
             for dim in DIMENSIONS:
                 ds = dim_scores.get(dim)
                 if ds is None or ds.is_stale:
                     await compute_dimension_score(db, ticker.symbol, dim)
-
             await compute_composite_score(db, ticker.symbol, weights)
+            recomputed = True
 
+    if recomputed:
         await db.commit()
+        comps, dims_by_ticker = await _load_scores()
 
-        # Re-fetch
-        comp_result = await db.execute(
-            select(CompositeScore).where(CompositeScore.ticker_id == ticker.id)
-        )
-        comp = comp_result.scalar_one_or_none()
-        if comp is None:
-            continue
-
-        dim_result = await db.execute(
-            select(DimensionScore).where(
-                DimensionScore.ticker_id == ticker.id
-            )
-        )
-        dims = [
-            {
-                "dimension": ds.dimension,
-                "score": ds.score,
-                "is_stale": ds.is_stale,
-                "computed_at": ds.computed_at,
-            }
-            for ds in dim_result.scalars().all()
-        ]
-
-        rankings.append({
+    rankings = [
+        {
             "symbol": ticker.symbol,
             "composite_score": comp.score,
-            "dimensions": dims,
-        })
+            "dimensions": [
+                {
+                    "dimension": ds.dimension,
+                    "score": ds.score,
+                    "is_stale": ds.is_stale,
+                    "computed_at": ds.computed_at,
+                }
+                for ds in dims_by_ticker.get(ticker.id, {}).values()
+            ],
+        }
+        for ticker in tickers
+        if (comp := comps.get(ticker.id)) is not None
+    ]
 
-    # Sort by composite score descending
     rankings.sort(key=lambda r: r["composite_score"], reverse=True)
-
-    return {
-        "rankings": rankings,
-        "weights": weights,
-    }
+    return {"rankings": rankings, "weights": weights}
 
 
 async def update_weights(