fix(sports): harden the B2/B3 capabilities against bad config and subclasses

Review pass on the phase B2-B4 changes. Every fix here is the same shape
as the crashes this PR already fixed in the hockey and baseball
extractors: a config or feed value that is present-but-wrong reaching
arithmetic or a comparison on a path with no guard.

celebrations:
- celebration_duration is coerced and floored at init. It is compared
  numerically in display() *outside* any try block, so a string from a
  hand-edited config propagated a TypeError straight out; zero or
  negative armed a celebration that could never render.
- A render failure now disarms instead of staying armed. It previously
  retried the same broken render on every frame for the rest of the
  window -- a traceback per frame, and no scorebug either.
- prune_score_baselines() for the live set. Only _check_for_win removed
  entries, so a game that left the live list any other way leaked its
  baseline and the dict grew all season.
- display() reuses has_active_celebration() rather than repeating its
  window comparison, and log lines carry a [Celebrations] prefix.

rotation:
- MAX_WEIGHT ceiling. A cycle is sum(weights) long and each step scans
  every game, so an unbounded weight from a misread config spins the
  display thread -- on a Pi that stalls rendering outright.
- register_rotation_strategy rejects a non-subclass factory at
  registration instead of failing frames later inside schedule().
- schedule() previews through type(self), so a subclass overriding
  next_game is previewed with its own ordering -- which is what the
  method promises.

sports_scroll:
- scroll_speed / scroll_delay coerced. dict.get(key, default) only helps
  when the key is absent; present-but-null reached the multiplication
  inside __init__ and the display failed to construct at all.
- update_scroll_position and get_visible_portion moved inside the try.
  They ran outside it, so a raise there reached the plugin's frame loop
  despite the comment promising none can.
- prepare_and_display guards the subclass call, so one sport's bad
  payload cannot take down the shared orchestration for the others.
- _current_game_type spells "nothing active" as "" in both classes; the
  manager said None while the display said "".

Not taken: the report that baseball's favorite-team debug path still
reads event-level status. Verified against current code -- there are no
remaining game_event["status"] reads in that file; it was fixed in
2486bdb and the finding is stale.

Gates: 747 core unit, 66 plugin safety.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgbA8SMutQQpXkMG8LMmC4

src/base_classes/sports/capabilities/celebrations.py

@@ -51,7 +51,20 @@ class CelebrationMixin:
         super().__init__(*args, **kwargs)
         mode_config = getattr(self, "mode_config", {}) or {}
         self.celebration_enabled = mode_config.get("celebration_enabled", True)
-        self.celebration_duration = mode_config.get("celebration_duration", 8)
+        # Coerced and floored at init: this value is compared numerically on the
+        # display path, where a string from a hand-edited config would raise
+        # TypeError outside any try block, and a zero or negative value would
+        # arm a celebration that can never render.
+        raw_duration = mode_config.get("celebration_duration", 8)
+        try:
+            self.celebration_duration = max(1.0, float(raw_duration))
+        except (TypeError, ValueError):
+            self.logger.warning(
+                "[Celebrations] Unusable celebration_duration %r; using 8s. "
+                "Set a positive number of seconds.",
+                raw_duration,
+            )
+            self.celebration_duration = 8.0
         # Both spellings: the soccer lineage ships `celebrate_opponent_goals`,
         # football ships `celebrate_opponent_scores`. Whichever the plugin's
         # schema declares is the one its users have set.
@@ -122,6 +135,25 @@ class CelebrationMixin:
         # Favorites exist but this team isn't one -> it's the opponent.
         return self.celebrate_opponent_scores
 
+    def prune_score_baselines(self, live_games: List[Dict]) -> None:
+        """Drop baselines for games no longer live.
+
+        Only :meth:`_check_for_win` removes entries, and it only fires for games
+        seen to go final. A game that vanishes from the live list any other way
+        — postponed, dropped by the feed, or simply still live when the board
+        restarts — leaves its baseline behind forever, so on a board that runs
+        all season the dict grows without bound.
+
+        Call this from ``update()`` with the current live set, alongside the
+        equivalent pruning in :meth:`SmoothWeightedRotation.next_game`.
+        """
+        live_ids = {g.get("id") for g in live_games}
+        self._score_baselines = {
+            gid: baseline
+            for gid, baseline in self._score_baselines.items()
+            if gid in live_ids
+        }
+
     def has_active_celebration(self) -> bool:
         """True while a celebration is within its display window."""
         celebration = self.active_celebration
@@ -255,7 +287,7 @@ class CelebrationMixin:
         # resumes on it.
         self.current_game = dict(game)
         self.logger.info(
-            f"Celebration ({kind}) armed: {phrase} "
+            f"[Celebrations] {kind} armed: {phrase} "
             f"[{game.get('away_abbr')} {away_score}-{home_score} {game.get('home_abbr')}]"
         )
 
@@ -323,7 +355,7 @@ class CelebrationMixin:
                     away_logo, (-2, center_y - away_logo.height // 2), away_logo
                 )
         except Exception as e:
-            self.logger.debug(f"Celebration logo load failed: {e}")
+            self.logger.debug(f"[Celebrations] Logo load failed: {e}")
 
         # Phrase across the top, shrunk to fit the panel width.
         phrase = celebration["phrase"]
@@ -365,12 +397,19 @@ class CelebrationMixin:
             return False
         celebration = self.active_celebration
         if celebration:
-            if time.time() - celebration["started_at"] < self.celebration_duration:
+            if self.has_active_celebration():
                 try:
                     self._draw_celebration_layout(celebration, force_clear)
                     return True
                 except Exception as e:
-                    self.logger.error(f"Error drawing celebration: {e}", exc_info=True)
+                    self.logger.error(
+                        f"[Celebrations] Error drawing celebration: {e}", exc_info=True
+                    )
+                    # Disarm rather than retry: the same render would fail on
+                    # every frame for the rest of the window, logging a
+                    # traceback each time and leaving the scorebug off screen.
+                    self.active_celebration = None
+                    self.last_game_switch = time.time()
             else:
                 self.active_celebration = None
                 # Reset the dwell so the scorebug resumes on the scoring/winning