fix(e5): address code-review findings (TMDB guid media_type, search ingest guard, discover keying)

Follow-ups from the epic-end /code-review of the E5 branch:

- tmdb.resolve_recs + people._resolve_known_for: match recommendations/
  credits to the library bucketed by media_type. TMDB movie ids and tv ids
  are independent sequences, so a bare `tmdb:<id>` match could deep-link a
  movie rec to an unrelated show (or vice-versa) on a numeric collision.
  Regression test added (test_resolve_recs_matches_by_media_type_not_bare_id).
- routes/search: wrap the _ingest_candidates call so a DB/enrich failure
  degrades to a 422 with a message instead of a bare 500 hidden behind the
  FE's generic "search failed" (extends the B-core-1 rationale); rollback on
  failure. Stamp enriched_at with its own timestamp taken after the enrich,
  not the stub-insert placeholder.
- routes/plex/discover: key serialized cards back by rating_key (globally
  unique in Plex) instead of id(obj); fix the stale rows 3-tuple annotation.

backend/app/routes/plex/discover.py

@@ -90,21 +90,16 @@ def _recently_added(
     ]
     tagged.sort(key=lambda t: (t[0] is not None, t[0]), reverse=True)
     top = tagged[:RAIL_LIMIT]
-    mcards = {
-        id(m): c
-        for m, c in zip(
-            [t[2] for t in top if t[1] == "movie"],
-            _movie_cards(db, uid, [t[2] for t in top if t[1] == "movie"]),
-        )
-    }
-    scards = {
-        id(s): c
-        for s, c in zip(
-            [t[2] for t in top if t[1] == "show"],
-            _show_cards(db, uid, [t[2] for t in top if t[1] == "show"]),
-        )
-    }
-    return [mcards[id(o)] if kind == "movie" else scards[id(o)] for _, kind, o in top]
+    # Key the serialized cards back by rating_key (globally unique in Plex — a movie and a show never
+    # share one), so the merge doesn't depend on object identity staying alive.
+    top_movies = [o for _, kind, o in top if kind == "movie"]
+    top_shows = [o for _, kind, o in top if kind == "show"]
+    mcards = {m.rating_key: c for m, c in zip(top_movies, _movie_cards(db, uid, top_movies))}
+    scards = {s.rating_key: c for s, c in zip(top_shows, _show_cards(db, uid, top_shows))}
+    return [
+        mcards[o.rating_key] if kind == "movie" else scards[o.rating_key]
+        for _, kind, o in top
+    ]
 
 
 def _continue_watching(
@@ -112,7 +107,7 @@ def _continue_watching(
 ) -> list[dict]:
     """Resume rail: in-progress movies + partially-watched shows, most-recently-progressed first.
     A movie's resume time is its own `progress_updated_at`; a show's is the max across its episodes."""
-    rows: list[tuple[object, object, dict]] = []  # (resumed_at, sentinel-ordinal, card)
+    rows: list[tuple[object, dict]] = []  # (resumed_at, card)
 
     if movie_ids:
         mrows = db.execute(
@@ -256,14 +251,15 @@ def _because_you_watched(
     }
     ordered_movies = [movies[rk] for rk in rks if rk in movies]
     ordered_shows = [shows[rk] for rk in rks if rk in shows]
-    mcards = {id(m): c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies))}
-    scards = {id(s): c for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows))}
+    # rating_key is globally unique in Plex, so it keys the serialized cards back safely (no id()).
+    mcards = {m.rating_key: c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies))}
+    scards = {s.rating_key: c for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows))}
     items: list[dict] = []
     for rk in rks:
-        if rk in movies:
-            items.append(mcards[id(movies[rk])])
-        elif rk in shows:
-            items.append(scards[id(shows[rk])])
+        if rk in mcards:
+            items.append(mcards[rk])
+        elif rk in scards:
+            items.append(scards[rk])
     if not items:
         return None
     return {"anchor": {"id": anchor.rating_key, "title": anchor.title}, "items": items}