Add a config toggle to enable/disable the YouTube Music source

- YouTubeConfiguration.Enabled (default true, Infrastructure): single
  switch for the whole source
- DisabledYouTubeMusicService: null-object IYouTubeMusicService that
  fails every call with Forbidden, registered instead of the real one
  when disabled (AddYouTubeMusicService) so no client is ever built
- AppSettings.json (Api + Worker): document YouTube.Enabled explicitly;
  overridable via YouTube__Enabled env var like every other section
- CurrentUser.cs: small unrelated cleanup, collapse the IsAuthenticated
  computation to a single null-coalescing expression

Search, albums, stream resolution and adding a new YouTube track all
surface as 403 Forbidden through the existing ErrorOr -> HTTP mapping.
Daily mix generation already treated a YouTube search failure as "no
YouTube candidates" and keeps working with local-only candidates —
added a test locking that in. Already-downloaded YouTube tracks are
unaffected since playback never goes through IYouTubeMusicService.

257/257 tests passing (7 new), 0 build warnings.

backend/Core/Musify.Infrastructure/Configuration/YouTubeConfiguration.cs

@@ -6,6 +6,11 @@ namespace Musify.Infrastructure.Configuration
     {
         public const string SectionName = "YouTube";
 
+        /// <summary>Turns the whole YouTube Music source on or off: search, albums, streaming
+        /// and adding new YouTube tracks all fail with a clear error while this is <c>false</c>,
+        /// and mix generation silently skips YouTube candidates instead of failing.</summary>
+        public bool Enabled { get; set; } = true;
+
         [Required]
         public string GeographicalLocation { get; set; } = "US";
 

backend/Core/Musify.Infrastructure/Services/DisabledYouTubeMusicService.cs

@@ -0,0 +1,37 @@
+using ErrorOr;
+using Musify.Application.Contracts;
+
+namespace Musify.Infrastructure.Services
+{
+    /// <summary>Stands in for <see cref="IYouTubeMusicService"/> when
+    /// <see cref="Musify.Infrastructure.Configuration.YouTubeConfiguration.Enabled"/> is <c>false</c>,
+    /// so the source can be turned off without a client ever being constructed. Every read fails
+    /// with the same <see cref="ErrorType.Forbidden"/> error; callers already treat a failed
+    /// YouTube call as "unavailable" (an HTTP error for direct requests, a skipped candidate for
+    /// mix generation), so nothing downstream needs to know the source is disabled specifically.</summary>
+    public sealed class DisabledYouTubeMusicService : IYouTubeMusicService
+    {
+        private static readonly Error DisabledError =
+            Error.Forbidden(description: "The YouTube Music source is disabled.");
+
+        public Task<ErrorOr<YouTubeSearchResult>> SearchSongsAsync(string query, string continuationToken, CancellationToken cancellationToken) =>
+            Task.FromResult<ErrorOr<YouTubeSearchResult>>(DisabledError);
+
+        public Task<ErrorOr<YouTubeAlbumSearchResult>> SearchAlbumsAsync(string query, string continuationToken, CancellationToken cancellationToken) =>
+            Task.FromResult<ErrorOr<YouTubeAlbumSearchResult>>(DisabledError);
+
+        public Task<ErrorOr<YouTubeAlbumDetail>> GetAlbumAsync(string albumId, CancellationToken cancellationToken) =>
+            Task.FromResult<ErrorOr<YouTubeAlbumDetail>>(DisabledError);
+
+        public Task<ErrorOr<YouTubeStreamInfo>> GetAudioStreamAsync(string videoId, CancellationToken cancellationToken) =>
+            Task.FromResult<ErrorOr<YouTubeStreamInfo>>(DisabledError);
+
+        public Task<ErrorOr<YouTubeSongResult>> GetSongAsync(string videoId, CancellationToken cancellationToken) =>
+            Task.FromResult<ErrorOr<YouTubeSongResult>>(DisabledError);
+
+        // Never reached in practice: every caller only reaches this after a successful search or
+        // song lookup above, neither of which can succeed while disabled. Passing the URL through
+        // unchanged is the safest thing to do if it's ever called anyway.
+        public string ResolveArtworkUrl(string thumbnailUrl) => thumbnailUrl;
+    }
+}

backend/Core/Musify.Infrastructure/Services/ServicesDependencyInjection.cs

@@ -1,8 +1,10 @@
 using Amazon.S3;
 using Hangfire;
 using Hangfire.PostgreSql;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Musify.Application.Configuration;
 using Musify.Infrastructure.Configuration;
@@ -102,7 +104,17 @@ namespace Musify.Infrastructure.Services
             serviceDescriptors.AddValidatedOptions<YouTubeConfiguration>(configuration, YouTubeConfiguration.SectionName);
 
             serviceDescriptors.AddMemoryCache();
-            serviceDescriptors.AddSingleton<IYouTubeMusicService, YouTubeMusicService>();
+            serviceDescriptors.AddSingleton<IYouTubeMusicService>(serviceProvider =>
+            {
+                var youTubeConfiguration = serviceProvider.GetRequiredService<YouTubeConfiguration>();
+                if (!youTubeConfiguration.Enabled)
+                    return new DisabledYouTubeMusicService();
+
+                return new YouTubeMusicService(
+                    youTubeConfiguration,
+                    serviceProvider.GetRequiredService<IMemoryCache>(),
+                    serviceProvider.GetRequiredService<ILogger<YouTubeMusicService>>());
+            } );
             return serviceDescriptors;
         }