[AZ-312] [AZ-313] [AZ-314] Split Services into per-component csprojs

Phase B of architecture coupling refactor (epic AZ-309). Replaces
the monolithic SatelliteProvider.Services with three per-component
csprojs to add a compiler-enforced module boundary (resolves F4):

- SatelliteProvider.Services.TileDownloader
- SatelliteProvider.Services.RegionProcessing
- SatelliteProvider.Services.RouteManagement

DI registrations relocated into per-component AddTileDownloader /
AddRegionProcessing / AddRouteManagement extension methods called
from Program.cs. RateLimitException moved to Common/Exceptions/ to
keep the three new csprojs as siblings (no Region->TileDownloader
ProjectReference). Dockerfiles and consumer csprojs (Api, Tests)
rewired to the new project paths. No DI lifetime or hosted-service
order changes.

Build: 0 warn, 0 err. Unit tests: 40/40. Smoke integration: green.
Co-authored-by: Cursor <cursoragent@cursor.com>

SatelliteProvider.Services.TileDownloader/TileService.cs

@@ -0,0 +1,182 @@
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
+using SatelliteProvider.Common.DTO;
+using SatelliteProvider.Common.Interfaces;
+using SatelliteProvider.Common.Utils;
+using SatelliteProvider.DataAccess.Models;
+using SatelliteProvider.DataAccess.Repositories;
+
+namespace SatelliteProvider.Services.TileDownloader;
+
+public class TileService : ITileService
+{
+    private static readonly TimeSpan TileCacheAbsolute = TimeSpan.FromHours(1);
+    private static readonly TimeSpan TileCacheSliding = TimeSpan.FromMinutes(30);
+    private static readonly TimeSpan TileResponseMaxAge = TimeSpan.FromDays(1);
+    private const string TileImageContentType = "image/jpeg";
+
+    private readonly ISatelliteDownloader _downloader;
+    private readonly ITileRepository _tileRepository;
+    private readonly IMemoryCache _cache;
+    private readonly ILogger<TileService> _logger;
+
+    public TileService(
+        ISatelliteDownloader downloader,
+        ITileRepository tileRepository,
+        IMemoryCache cache,
+        ILogger<TileService> logger)
+    {
+        _downloader = downloader;
+        _tileRepository = tileRepository;
+        _cache = cache;
+        _logger = logger;
+    }
+
+    public async Task<List<TileMetadata>> DownloadAndStoreTilesAsync(
+        double latitude, 
+        double longitude, 
+        double sizeMeters, 
+        int zoomLevel, 
+        CancellationToken cancellationToken = default)
+    {
+        var currentVersion = DateTime.UtcNow.Year;
+        
+        var existingTiles = await _tileRepository.GetTilesByRegionAsync(latitude, longitude, sizeMeters, zoomLevel);
+        var existingTilesList = existingTiles.Where(t => t.Version == currentVersion).ToList();
+        
+        var centerPoint = new GeoPoint(latitude, longitude);
+        
+        var existingTileInfos = existingTilesList
+            .Select(t => new ExistingTileInfo(t.Latitude, t.Longitude, t.TileZoom))
+            .ToList();
+        
+        var downloadedTiles = await _downloader.GetTilesWithMetadataAsync(
+            centerPoint, 
+            sizeMeters / 2, 
+            zoomLevel, 
+            existingTileInfos,
+            cancellationToken);
+        
+        var result = new List<TileMetadata>();
+        
+        foreach (var existingTile in existingTilesList)
+        {
+            result.Add(MapToMetadata(existingTile));
+        }
+        
+        foreach (var downloadedTile in downloadedTiles)
+        {
+            var tileEntity = BuildTileEntity(downloadedTile, currentVersion);
+            await _tileRepository.InsertAsync(tileEntity);
+            result.Add(MapToMetadata(tileEntity));
+        }
+
+        return result;
+    }
+
+    public async Task<TileMetadata?> GetTileAsync(Guid id)
+    {
+        var tile = await _tileRepository.GetByIdAsync(id);
+        return tile != null ? MapToMetadata(tile) : null;
+    }
+
+    public async Task<IEnumerable<TileMetadata>> GetTilesByRegionAsync(
+        double latitude, 
+        double longitude, 
+        double sizeMeters, 
+        int zoomLevel)
+    {
+        var tiles = await _tileRepository.GetTilesByRegionAsync(latitude, longitude, sizeMeters, zoomLevel);
+        return tiles.Select(MapToMetadata);
+    }
+
+    public async Task<TileBytes> GetOrDownloadTileAsync(int z, int x, int y, CancellationToken cancellationToken = default)
+    {
+        var cacheKey = $"tile_{z}_{x}_{y}";
+        var etag = $"\"{z}_{x}_{y}\"";
+
+        if (_cache.TryGetValue(cacheKey, out byte[]? cachedBytes) && cachedBytes != null)
+        {
+            return new TileBytes(cachedBytes, TileImageContentType, etag, TileResponseMaxAge);
+        }
+
+        string filePath;
+        var existing = await _tileRepository.GetByTileCoordinatesAsync(z, x, y);
+        if (existing != null && File.Exists(existing.FilePath))
+        {
+            filePath = existing.FilePath;
+        }
+        else
+        {
+            var tileCenter = GeoUtils.TileToWorldPos(x, y, z);
+            var downloaded = await _downloader.DownloadSingleTileAsync(tileCenter.Lat, tileCenter.Lon, z, cancellationToken);
+            var entity = BuildTileEntity(downloaded, DateTime.UtcNow.Year);
+            await _tileRepository.InsertAsync(entity);
+            filePath = entity.FilePath;
+        }
+
+        var bytes = await File.ReadAllBytesAsync(filePath, cancellationToken);
+        _cache.Set(cacheKey, bytes, new MemoryCacheEntryOptions
+        {
+            AbsoluteExpirationRelativeToNow = TileCacheAbsolute,
+            SlidingExpiration = TileCacheSliding
+        });
+
+        return new TileBytes(bytes, TileImageContentType, etag, TileResponseMaxAge);
+    }
+
+    public async Task<TileMetadata> DownloadAndStoreSingleTileAsync(
+        double latitude,
+        double longitude,
+        int zoomLevel,
+        CancellationToken cancellationToken = default)
+    {
+        var downloaded = await _downloader.DownloadSingleTileAsync(latitude, longitude, zoomLevel, cancellationToken);
+        var entity = BuildTileEntity(downloaded, DateTime.UtcNow.Year);
+        await _tileRepository.InsertAsync(entity);
+        return MapToMetadata(entity);
+    }
+
+    private static TileEntity BuildTileEntity(DownloadedTileInfoV2 downloaded, int currentVersion)
+    {
+        var now = DateTime.UtcNow;
+        return new TileEntity
+        {
+            Id = Guid.NewGuid(),
+            TileZoom = downloaded.ZoomLevel,
+            TileX = downloaded.X,
+            TileY = downloaded.Y,
+            Latitude = downloaded.CenterLatitude,
+            Longitude = downloaded.CenterLongitude,
+            TileSizeMeters = downloaded.TileSizeMeters,
+            TileSizePixels = 256,
+            ImageType = "jpg",
+            MapsVersion = $"downloaded_{now:yyyy-MM-dd}",
+            Version = currentVersion,
+            FilePath = downloaded.FilePath,
+            CreatedAt = now,
+            UpdatedAt = now
+        };
+    }
+
+    private static TileMetadata MapToMetadata(TileEntity entity)
+    {
+        return new TileMetadata
+        {
+            Id = entity.Id,
+            TileZoom = entity.TileZoom,
+            TileX = entity.TileX,
+            TileY = entity.TileY,
+            Latitude = entity.Latitude,
+            Longitude = entity.Longitude,
+            TileSizeMeters = entity.TileSizeMeters,
+            TileSizePixels = entity.TileSizePixels,
+            ImageType = entity.ImageType,
+            MapsVersion = entity.MapsVersion,
+            Version = entity.Version,
+            FilePath = entity.FilePath,
+            CreatedAt = entity.CreatedAt,
+            UpdatedAt = entity.UpdatedAt
+        };
+    }
+}