feat: add apple music support

- filter.zig: add music.apple.com domain detection
- stats.zig: add apple platform counter
- dashboard.zig: display apple music in platforms list

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/feed/filter.zig

···
     "plyr.fm",
     "open.spotify.com",
     "spotify.link",
+    "music.apple.com",
 };
 
 fn includeMusicLinks(record: Record) ?bool {
···
         return .spotify;
     }
     if (mem.indexOf(u8, uri, "plyr.fm") != null) return .plyr;
+    if (mem.indexOf(u8, uri, "music.apple.com") != null) return .apple;
     return null;
 }
 
···
 
     // plyr
     try testing.expectEqual(.plyr, detectPlatform("https://plyr.fm/track/123"));
+
+    // apple music
+    try testing.expectEqual(.apple, detectPlatform("https://music.apple.com/au/album/gooey/1440817571"));
 
     // unknown
     try testing.expectEqual(null, detectPlatform("https://youtube.com/watch?v=123"));

src/server/dashboard.zig

···
 
     // get platform counts
     const platforms = s.getPlatformCounts();
-    const total = platforms.soundcloud + platforms.bandcamp + platforms.spotify + platforms.plyr;
+    const total = platforms.soundcloud + platforms.bandcamp + platforms.spotify + platforms.plyr + platforms.apple;
 
     if (total > 0) {
         const PlatformData = struct { name: []const u8, count: u64, color: []const u8 };
···
             .{ .name = "bandcamp", .count = platforms.bandcamp, .color = "#1da0c3" },
             .{ .name = "spotify", .count = platforms.spotify, .color = "#1db954" },
             .{ .name = "plyr.fm", .count = platforms.plyr, .color = "#7c3aed" },
+            .{ .name = "apple music", .count = platforms.apple, .color = "#fa243c" },
         };
 
         // sort by count descending

src/server/stats.zig

···
 
 const STATS_PATH = "/data/stats.json";
 
-pub const Platform = enum { soundcloud, bandcamp, spotify, plyr };
+pub const Platform = enum { soundcloud, bandcamp, spotify, plyr, apple };
 
 pub const Stats = struct {
     started_at: i64,
···
     bandcamp: Atomic(u64),
     spotify: Atomic(u64),
     plyr: Atomic(u64),
+    apple: Atomic(u64),
 
     // for lag trend tracking
     prev_lag_ms: Atomic(i64),
···
             .bandcamp = Atomic(u64).init(0),
             .spotify = Atomic(u64).init(0),
             .plyr = Atomic(u64).init(0),
+            .apple = Atomic(u64).init(0),
             .prev_lag_ms = Atomic(i64).init(0),
         };
         self.load();
···
         if (root.get("plyr")) |v| if (v == .integer) {
             self.plyr.store(@intCast(@max(0, v.integer)), .monotonic);
         };
+        if (root.get("apple")) |v| if (v == .integer) {
+            self.apple.store(@intCast(@max(0, v.integer)), .monotonic);
+        };
 
         std.debug.print("loaded stats from {s}\n", .{STATS_PATH});
     }
···
 
         var buf: [512]u8 = undefined;
         const data = std.fmt.bufPrint(&buf,
-            \\{{"messages":{},"matches":{},"cumulative_uptime":{},"soundcloud":{},"bandcamp":{},"spotify":{},"plyr":{}}}
+            \\{{"messages":{},"matches":{},"cumulative_uptime":{},"soundcloud":{},"bandcamp":{},"spotify":{},"plyr":{},"apple":{}}}
         , .{
             self.messages.load(.monotonic),
             self.matches.load(.monotonic),
···
             self.bandcamp.load(.monotonic),
             self.spotify.load(.monotonic),
             self.plyr.load(.monotonic),
+            self.apple.load(.monotonic),
         }) catch return;
 
         file.writeAll(data) catch return;
···
             .bandcamp => _ = self.bandcamp.fetchAdd(1, .monotonic),
             .spotify => _ = self.spotify.fetchAdd(1, .monotonic),
             .plyr => _ = self.plyr.fetchAdd(1, .monotonic),
+            .apple => _ = self.apple.fetchAdd(1, .monotonic),
         }
     }
 
-    pub fn getPlatformCounts(self: *const Stats) struct { soundcloud: u64, bandcamp: u64, spotify: u64, plyr: u64 } {
+    pub fn getPlatformCounts(self: *const Stats) struct { soundcloud: u64, bandcamp: u64, spotify: u64, plyr: u64, apple: u64 } {
         return .{
             .soundcloud = self.soundcloud.load(.monotonic),
             .bandcamp = self.bandcamp.load(.monotonic),
             .spotify = self.spotify.load(.monotonic),
             .plyr = self.plyr.load(.monotonic),
+            .apple = self.apple.load(.monotonic),
         };
     }
 
···
         .bandcamp = Atomic(u64).init(0),
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
+        .apple = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };
 
···
         .bandcamp = Atomic(u64).init(0),
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
+        .apple = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };
 
     s.recordPlatform(.soundcloud);
     s.recordPlatform(.soundcloud);
     s.recordPlatform(.bandcamp);
+    s.recordPlatform(.apple);
 
     const counts = s.getPlatformCounts();
     try std.testing.expectEqual(2, counts.soundcloud);
     try std.testing.expectEqual(1, counts.bandcamp);
     try std.testing.expectEqual(0, counts.spotify);
     try std.testing.expectEqual(0, counts.plyr);
+    try std.testing.expectEqual(1, counts.apple);
 }
 
 test "Stats.getStatus returns live or catching_up" {
···
         .bandcamp = Atomic(u64).init(0),
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
+        .apple = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };