Enhanced Metadata Resolution, Stream Analysis & Improved STRM-Output. Added connection priority management.

**Description:**
This PR introduces a major overhaul of how streams are analyzed and connections are managed. It integrates `ffprobe` for deep stream analysis, adds a background task queue for metadata resolution to prevent UI blocking, introduces a connection priority system, and adds support for Live TV probing.

### 🚀 Key Features

*   **FFprobe Integration & Live TV Probing**:
    *   Automatically probes streams (VOD/Series **and now Live TV**) to determine resolution, codecs (HEVC/AV1), dynamic range (HDR/DV), bit depth, and audio channels.
    *   **Safe Probing**: Probing strictly respects the provider's `max_connections` limit.
    *   Docker images now include static `ffmpeg/ffprobe` binaries.

*   **Smart Connection Management (Priority System)**:
    *   Introduced a priority system for connections to manage provider limits intelligently.
    *   **Preemption**: Users with higher priority can preempt (kick) lower priority connections when provider slots are full.
    *   **Background Queue**: Metadata resolution and stream analysis run as background tasks (Priority 0). They only run when connection slots are idle and yield immediately if a real user needs to stream.

*   **Enhanced Metadata Resolution**:
    *   **Fallback Logic**: If a provider is missing the TMDB ID or Release Date, the system resolves them via the TMDB API.
    *   **Smart Title Cleaning**: Implemented a centralized cleaner to strip common IPTV prefixes before attempting metadata matches or generating filenames, significantly improving match rates.

*   **Improved Output**:
    *   **Quality Tags**: Filenames in STRM files now include detailed tags (e.g., `Movie - [4K HEVC HDR].strm`).
    *   **Flat Grouping**: `flat: true` now correctly groups multi-version movies into single folders based on TMDB ID.
    *   **Global Series Date**: Ensures consistent series folder naming even if episodes have different years.

backend/src/processing/processor/library.rs

@@ -103,18 +103,19 @@ fn to_playlist_item(entry: &MetadataCacheEntry, input_name: &Arc<str>, group_nam
                                         item_type: PlaylistItemType::LocalSeries,
                                         category_id: 0,
                                         input_name: Arc::clone(input_name),
-                                        additional_properties: Some(StreamProperties::Episode(EpisodeStreamProperties {
+                                        additional_properties: Some(StreamProperties::Episode(Box::new(EpisodeStreamProperties {
                                             episode_id: episode.id,
                                             episode: episode.episode_num,
                                             season: episode.season,
                                             added: Some(episode.added.clone()),
                                             release_date: Some(episode.release_date.clone()),
+                                            series_release_date: None,
                                             tmdb: episode.tmdb,
                                             movie_image: logo,
                                             container_extension: container_extension.intern(),
                                             audio: None,
                                             video: None,
-                                        })),
+                                        }))),
                                         ..Default::default()
                                     }
                                 });
@@ -287,6 +288,7 @@ pub fn metadata_cache_entry_to_xtream_series_info(
                 direct_source: episode.file_path.clone().into(),
                 tmdb: tmdb_id,
                 release_date: episode_release_date.clone().into(),
+                series_release_date: None,
                 plot: episode.plot.clone().map(Into::into),
                 crew: Some(Arc::clone(&actor_names)),
                 duration_secs: episode.runtime.map_or(0, |r| r * 60),