feat(emby): add Emby as a MediaBrowser backend alongside Jellyfin

Emby is Jellyfin's upstream ancestor and speaks a near-identical MediaBrowser
API, so the existing Jellyfin stack is parameterised by a `MediaBrowserDialect`
rather than forked. `JellyfinClient`, its auth service, endpoint discovery, LAN
discovery, and the add/edit connection screens all take the dialect and keep one
implementation; `MediaBackend.emby` and `ConnectionKind.emby` carry it through
the neutral models, the Drift `kind` discriminator, downloads, and caches.

Every divergence below was measured against a live Emby 4.9.5 server, not
inferred from documentation, and each is documented at its capability getter.
Jellyfin's request strings stay byte-identical so nothing about its behaviour
changes.

Routes and auth
- Emby only accepts the pre-10.9 user-scoped item routes (`/Users/{id}/Items/…`,
  `/Users/{id}/PlayedItems/…`, `/Users/{id}/FavoriteItems/…`); the unprefixed
  forms Jellyfin 10.11 added return 404.
- The API is also served under a legacy `/emby` prefix, and both dialects accept
  the token as `X-Emby-Token` or `api_key=`.
- Emby answers only its own LAN discovery datagram ("who is EmbyServer?") and
  ignores Jellyfin's; its default HTTPS port is 8920.
- No `/QuickConnect` route exists, so Quick Connect stays Jellyfin-only.

Row fields Emby withholds
- `ProductionYear`, `OfficialRating`, `PremiereDate` and `DateCreated` are absent
  from list rows unless named in `Fields`, which would otherwise strip the year
  and age-rating badge from every card in the app.
- `UserData.LastPlayedDate` never appears on a list row under `Fields=UserData`,
  `EnableUserData=true` or the user-scoped `Ids=` form — only on the single-item
  detail route, or when the Emby-specific `UserDataLastPlayedDate` token is
  requested. Without it every recency-ordered surface silently degrades to
  library-add time, and `JellyfinApiCache.applyWatchState` stamps
  `DateTime.now()` on watched rows, so an offline watch-state pull would rewrite
  the cached play time of everything it walked.

Continue Watching and Next Up
- Emby computes Next Up per series only: the library-wide `/Shows/NextUp` query
  returns nothing under every parameter combination tried. The shelf is
  therefore reconstructed from a played-episode recency scan plus one
  `/Shows/NextUp?SeriesId=` per distinct series, bounded by a shared wall clock
  that covers the scan as well — per-request timeouts cannot bound the pass
  because `MediaServerHttpClient` times the connect and receive phases
  independently. Rows are stamped with their series' newest play from the same
  response that ordered them, so no per-series enrichment request is needed.
- `/Shows/NextUp` ignores `NextUpDateCutoff`, and no server-side played-date
  filter exists to delegate to (`MinDatePlayed` and `MinDateLastPlayed` are
  ignored; `MinDateLastSaved`, `MinDateCreated` and `MinPremiereDate` filter
  unrelated dates), so the 365-day window is applied to the scanned dates.
- The resume route returns items with no saved position, including plain next
  episodes, so the Emby resume leg reads from `/Items?Filters=IsResumable`.
- Emby is ahead of Jellyfin in one place: `/Users/{id}/Items/{id}/HideFromResume`
  makes Continue Watching removal a real capability.

Everything else
- `/Sessions/Playing` and `/Sessions/Playing/Progress` reject a body with no
  `PlaySessionId` (HTTP 400), so playback reporting always sends one.
- Passing any `MediaTypes` value to the playlist query returns an empty list.
- There is no aggregate `/Items/Filters` route; the four filter facets are
  reassembled from `/Genres`, `/OfficialRatings`, `/Studios` and `/Tags`.
- Metadata writes take name-pair lists (`Genres: [{'Name': 'Action'}]`); the
  plain string array is accepted and then silently discarded.
- Custom artwork uploads must be base64 text, not raw bytes — which was broken
  for Jellyfin too and is fixed for both.
- Trickplay, media segments and lyrics 404 on Emby, so scrub previews are absent
  and intro/credit markers fall back to chapter names.

Verified against a local Emby 4.9.5 and a Jellyfin 10.11.11 control server:
onboarding, browse, detail, playable stream URLs serving real bytes, subtitle
sidecars, watch-state write and restore, hubs, cross-server aggregation and
search across both backends simultaneously.

lib/services/api_cache.dart

@@ -12,18 +12,21 @@ import '../utils/isolate_helper.dart';
 ///
 /// Stores raw JSON keyed by `serverId:endpoint` in the shared `ApiCache`
 /// Drift table. `serverId` values are globally unique across connected
-/// backends, so Plex and Jellyfin entries never collide despite sharing
+/// backends, so Plex and MediaBrowser entries never collide despite sharing
 /// the same table.
 ///
-/// Plex- and Jellyfin-specific helpers (item-id pinning, metadata parsing)
+/// Plex- and MediaBrowser-specific helpers (item-id pinning, metadata parsing)
 /// live on subclasses [PlexApiCache] / [JellyfinApiCache], which also
 /// implement the abstract [getMetadata] / [pinForOffline] / [deleteForItem]
 /// methods so callers can dispatch via [forBackend] instead of switching on
 /// the backend type at every call site.
 class ApiCacheSingleton<T extends ApiCache> {
-  ApiCacheSingleton(this.backend, this.typeName);
+  ApiCacheSingleton(this.backends, this.typeName);
 
-  final MediaBackend backend;
+  /// Every backend this cache answers for. Jellyfin and Emby share one
+  /// instance: their DTO shapes are identical and cache rows are keyed by the
+  /// compound `machineId/userId` scope, so there is nothing to isolate.
+  final Set<MediaBackend> backends;
   final String typeName;
   T? _instance;
 
@@ -37,7 +40,7 @@ class ApiCacheSingleton<T extends ApiCache> {
 
   void install(T instance) {
     _instance = instance;
-    ApiCache.registerInstance(backend, instance);
+    ApiCache.registerInstance(instance, backends);
   }
 }
 
@@ -65,14 +68,17 @@ Map<String, MediaItem> decodeCachedMediaRows<T>(
 abstract class ApiCache {
   static final Map<MediaBackend, ApiCache> _byBackend = {};
 
-  /// Registers a backend cache. A new database marks a new application/test
-  /// lifecycle, so registrations tied to the previous database are discarded
-  /// instead of leaving backend dispatch pointed at a closed connection.
-  static void registerInstance(MediaBackend backend, ApiCache cache) {
-    if (_byBackend.values.any((registered) => !identical(registered.database, cache.database))) {
+  /// Registers [instance] for each requested backend. A new database marks a
+  /// new application/test lifecycle, so registrations tied to the previous
+  /// database are discarded instead of leaving backend dispatch pointed at a
+  /// closed connection.
+  static void registerInstance(ApiCache instance, Set<MediaBackend> backends) {
+    if (_byBackend.values.any((registered) => !identical(registered.database, instance.database))) {
       _byBackend.clear();
     }
-    _byBackend[backend] = cache;
+    for (final backend in backends) {
+      _byBackend[backend] = instance;
+    }
   }
 
   /// Pick the cache for [backend]. Plex is the legacy default — covers items
@@ -169,7 +175,7 @@ abstract class ApiCache {
   /// Pull pinned rows for [serverId] and extract the first capture group of
   /// [keyPattern] from each `cacheKey`. Returns the unique set of captured
   /// ids — backend subclasses use this to enumerate their pinned items
-  /// (Plex ratingKeys, Jellyfin item ids).
+  /// (Plex ratingKeys, MediaBrowser item ids).
   Future<Set<String>> extractPinnedIds(ServerId serverId, RegExp keyPattern) async {
     final rows = await (_db.select(
       _db.apiCache,
@@ -215,7 +221,7 @@ abstract class ApiCache {
   /// [itemId] so reloads (`getMetadata` / `getAllPinnedMetadata`) reflect the
   /// state without having to refetch from the server. No-op when the row
   /// isn't cached. Backend subclasses know which JSON fields to mutate
-  /// (Plex `viewCount`, Jellyfin `UserData.PlayCount` / `Played`).
+  /// (Plex `viewCount`, MediaBrowser `UserData.PlayCount` / `Played`).
   ///
   /// Optional positional progress fields ([viewOffsetMs], [lastViewedAt],
   /// [viewedLeafCount]) let the offline-watch-sync service mirror richer
@@ -228,7 +234,7 @@ abstract class ApiCache {
   /// shape + units are not. Adding a new watch-state input here means
   /// updating *both* concrete impls ([PlexApiCache.applyWatchState],
   /// [JellyfinApiCache.applyWatchState]) — Plex stores epoch-seconds and
-  /// flat fields, Jellyfin stores ISO-8601 + ticks under `UserData`.
+  /// flat fields, while Jellyfin and Emby store ISO-8601 + ticks under `UserData`.
   /// The mutations are too short (~3 lines per backend) for a shared
   /// adapter to be a net win, so they live duplicated by design.
   Future<void> applyWatchState({