refactor: Clean up dead code and simplify pmoserver REST API

Changes:
1. Removed dead code from paradise/worker.rs:
   - Unused process_song() method
   - Unused DecodedBlock struct
   - Unused helper functions: song_duration_ms, ms_to_frames, decode_block_audio

2. Simplified pmoserver_ext.rs (840 → 383 lines):
   - Removed complex orchestration endpoints (status, playlist, history, streaming)
   - Kept only simple API access endpoints:
     * /now-playing
     * /block/current
     * /block/{event_id}
     * /channels
   - Removed dependencies on RadioParadiseSource and ParadiseChannel

3. Created channels.rs:
   - Extracted channel definitions from paradise/channel.rs
   - Pure data module with no orchestration logic
   - Contains: ParadiseChannelKind, ChannelDescriptor, ALL_CHANNELS

Note: This is work in progress. Still need to update lib.rs and remove
unused modules once dependencies are fully resolved.

pmoparadise/src/channels.rs

@@ -0,0 +1,143 @@
+//! Radio Paradise channel definitions
+//!
+//! This module defines the available Radio Paradise channels and their metadata.
+
+use std::str::FromStr;
+
+/// Logical identifier for a Radio Paradise channel.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ParadiseChannelKind {
+    Main,
+    Mellow,
+    Rock,
+    Eclectic,
+}
+
+impl ParadiseChannelKind {
+    pub const fn id(self) -> u8 {
+        match self {
+            Self::Main => 0,
+            Self::Mellow => 1,
+            Self::Rock => 2,
+            Self::Eclectic => 3,
+        }
+    }
+
+    pub const fn slug(self) -> &'static str {
+        match self {
+            Self::Main => "main",
+            Self::Mellow => "mellow",
+            Self::Rock => "rock",
+            Self::Eclectic => "eclectic",
+        }
+    }
+
+    pub const fn display_name(self) -> &'static str {
+        match self {
+            Self::Main => "Main Mix",
+            Self::Mellow => "Mellow Mix",
+            Self::Rock => "Rock Mix",
+            Self::Eclectic => "Eclectic Mix",
+        }
+    }
+
+    pub const fn description(self) -> &'static str {
+        match self {
+            Self::Main => "Eclectic mix of rock, world, electronica, and more",
+            Self::Mellow => "Mellower, less aggressive music",
+            Self::Rock => "Heavier, more guitar-driven music",
+            Self::Eclectic => "Curated worldwide selection",
+        }
+    }
+}
+
+impl FromStr for ParadiseChannelKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s.to_ascii_lowercase().as_str() {
+            "main" | "0" => Ok(Self::Main),
+            "mellow" | "1" => Ok(Self::Mellow),
+            "rock" | "2" => Ok(Self::Rock),
+            "eclectic" | "3" => Ok(Self::Eclectic),
+            other => Err(anyhow::anyhow!("Unknown Radio Paradise channel: {}", other)),
+        }
+    }
+}
+
+/// Metadata descriptor for a channel.
+#[derive(Debug, Clone, Copy)]
+pub struct ChannelDescriptor {
+    pub kind: ParadiseChannelKind,
+    pub id: u8,
+    pub slug: &'static str,
+    pub display_name: &'static str,
+    pub description: &'static str,
+}
+
+impl ChannelDescriptor {
+    pub const fn new(kind: ParadiseChannelKind) -> Self {
+        Self {
+            id: kind.id(),
+            slug: kind.slug(),
+            display_name: kind.display_name(),
+            description: kind.description(),
+            kind,
+        }
+    }
+}
+
+/// All available Radio Paradise channels
+pub const ALL_CHANNELS: [ChannelDescriptor; 4] = [
+    ChannelDescriptor::new(ParadiseChannelKind::Main),
+    ChannelDescriptor::new(ParadiseChannelKind::Mellow),
+    ChannelDescriptor::new(ParadiseChannelKind::Rock),
+    ChannelDescriptor::new(ParadiseChannelKind::Eclectic),
+];
+
+/// Returns the maximum valid channel ID
+pub const fn max_channel_id() -> u8 {
+    (ALL_CHANNELS.len() - 1) as u8
+}
+
+/// Default maximum number of tracks to keep in history
+///
+/// This is used as the default if not configured via pmoconfig.
+/// Value: 100 tracks - represents ~5-8 hours of playback history
+pub const HISTORY_DEFAULT_MAX_TRACKS: usize = 100;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_channel_ids() {
+        assert_eq!(ParadiseChannelKind::Main.id(), 0);
+        assert_eq!(ParadiseChannelKind::Mellow.id(), 1);
+        assert_eq!(ParadiseChannelKind::Rock.id(), 2);
+        assert_eq!(ParadiseChannelKind::Eclectic.id(), 3);
+    }
+
+    #[test]
+    fn test_max_channel_id() {
+        assert_eq!(max_channel_id(), 3);
+    }
+
+    #[test]
+    fn test_all_channels_length() {
+        assert_eq!(ALL_CHANNELS.len(), 4);
+    }
+
+    #[test]
+    fn test_channel_from_str() {
+        assert!(matches!(
+            "main".parse::<ParadiseChannelKind>(),
+            Ok(ParadiseChannelKind::Main)
+        ));
+        assert!(matches!(
+            "0".parse::<ParadiseChannelKind>(),
+            Ok(ParadiseChannelKind::Main)
+        ));
+        assert!("invalid".parse::<ParadiseChannelKind>().is_err());
+    }
+}