fix(queue): dedupe episodeDict at read boundary + trust server response

The 'episodes added to download queue never shown' symptom has two
layered causes that masked each other:

1. The 'episodes' table has no UNIQUE constraint on
   (series_id, season, episode_number), so historical scans can leave
   duplicate rows behind. AnimeSeries.episodeDict iterated the
   SQLAlchemy 'episodes' relationship without deduping, so the dict
   exposed duplicate entries to list_missing() and the queue UI.
   The frontend forwarded the duplicated episode list verbatim to
   POST /api/queue/add; the backend's pending-episode dedup then
   rejected every duplicate as 'already pending' and the user saw
   'Skipped 44 duplicate episodes, Added 0'.

2. selection-manager.downloadSelected counted 'episodes.length'
   (the input array) instead of data.added_items.length (the
   server-confirmed count). Combined with the backend returning
   success on an empty add, the user saw a misleading 'Added 44
   episode(s)' toast for an empty queue.

Fix: dedupe at the read boundary. The episodeDict property now
filters duplicate (season, episode_number) pairs from both the
DB-loaded relationship and the legacy _episode_dict_cache path.
Existing duplicate rows in the user's DB are inert — the read
filter makes them invisible to the rest of the stack. The
frontend now trusts the server response, logs a console warning
when an input list shrinks to zero added items, and shows an
accurate toast.

Tests:
- TestEpisodeDictDedup class with 4 regression tests covering:
  * duplicate relationship rows deduped
  * is_downloaded rows still filtered out
  * _episode_dict_cache path also deduped (set by scanners/loaders
    that may store duplicates)
  * dedup is per-(season, ep_num), preserving legitimate
    same-ep-num-across-different-seasons entries

Verified manually against the user's backup DB: 'erased' has 44
duplicate rows in the episodes table; episodeDict now returns
{1: [1..12]} instead of {1: [1,1,2,2,3,3,3,3,...]}, matching the
12-episode canonical list.

tests/unit/test_database_models.py

@@ -308,6 +308,125 @@ class TestAnimeSeries:
         assert len(with_tmdb) == 2
 
 
+class TestEpisodeDictDedup:
+    """Regression tests for the duplicate-episode-row guard.
+
+    The ``episodes`` table has no UNIQUE constraint on
+    ``(series_id, season, episode_number)``, so historical scans can
+    leave duplicate rows behind. ``AnimeSeries.episodeDict`` is the
+    read boundary consumed by ``list_missing()`` and the queue UI;
+    it must never expose duplicates, or the frontend forwards them
+    verbatim to the queue API and every duplicate is rejected as
+    "already pending" — the user sees an empty queue and a misleading
+    "Added N" toast.
+    """
+
+    def _make_series(self, db_session: Session, key: str) -> AnimeSeries:
+        series = AnimeSeries(
+            key=key,
+            name=key.replace("-", " ").title(),
+            site="https://aniworld.to",
+            folder=f"/anime/{key}",
+        )
+        db_session.add(series)
+        db_session.commit()
+        return series
+
+    def test_episodeDict_dedupes_duplicate_relationship_rows(
+        self, db_session: Session
+    ):
+        """Duplicate Episode rows in the same series must not
+        duplicate the entries in ``episodeDict``."""
+        series = self._make_series(db_session, "dedup-rel")
+
+        # Three duplicate rows for (S1, E3) — exactly the pattern the
+        # scanner accumulates across repeated rescans.
+        for _ in range(3):
+            db_session.add(
+                Episode(series_id=series.id, season=1, episode_number=3)
+            )
+        # One row each for the surrounding unique episodes.
+        for ep in (1, 2, 4):
+            db_session.add(
+                Episode(series_id=series.id, season=1, episode_number=ep)
+            )
+        db_session.commit()
+
+        result = series.episodeDict
+
+        # Order depends on SQLAlchemy row order, which is not strictly
+        # insertion order — only the *set* of episodes matters here.
+        assert set(result.keys()) == {1}
+        assert set(result[1]) == {1, 2, 3, 4}
+        # Defensive: no season has duplicate episode numbers.
+        for season, eps in result.items():
+            assert len(eps) == len(set(eps)), (
+                f"season {season} has duplicate episode numbers: {eps}"
+            )
+
+    def test_episodeDict_excludes_downloaded_episodes(
+        self, db_session: Session
+    ):
+        """is_downloaded rows must still be filtered out, and a
+        duplicate non-downloaded row must not appear twice."""
+        series = self._make_series(db_session, "dedup-downloaded")
+
+        db_session.add(
+            Episode(series_id=series.id, season=1, episode_number=1)
+        )
+        # Downloaded row at (S1, E2): must be filtered out.
+        db_session.add(
+            Episode(
+                series_id=series.id,
+                season=1,
+                episode_number=2,
+                is_downloaded=True,
+            )
+        )
+        db_session.commit()
+
+        assert series.episodeDict == {1: [1]}
+
+    def test_episodeDict_dedupes_cached_value(self, db_session: Session):
+        """The legacy ``_episode_dict_cache`` path (used by
+        ``SerieScanner.scan_single_series`` for new series and by the
+        legacy JSON loader) must also dedupe, since loaders that set
+        the cache directly can introduce duplicates too."""
+        series = self._make_series(db_session, "dedup-cache")
+
+        # No episodes in the DB at all — the property will fall back
+        # to the cache.
+        series._episode_dict_cache = {1: [3, 3, 3, 4, 4]}
+
+        assert series.episodeDict == {1: [3, 4]}
+
+    def test_episodeDict_preserves_unique_entries_across_seasons(
+        self, db_session: Session
+    ):
+        """Dedup must be per-(season, episode_number), not
+        per-episode_number alone — same ep number in different
+        seasons is legitimate and must be preserved."""
+        series = self._make_series(db_session, "multi-season")
+
+        for season, ep in [(1, 1), (1, 2), (2, 1), (2, 2), (2, 2)]:
+            db_session.add(
+                Episode(
+                    series_id=series.id,
+                    season=season,
+                    episode_number=ep,
+                )
+            )
+        db_session.commit()
+
+        result = series.episodeDict
+
+        # Order is not guaranteed across SQLAlchemy relationships;
+        # compare as sets.
+        assert set(result.keys()) == {1, 2}
+        assert set(result[1]) == {1, 2}
+        assert set(result[2]) == {1, 2}
+
+
 class TestEpisode:
     """Test cases for Episode model."""