Add DeepZoom static preview services, tests, and samples

Extract the core DeepZoom rendering system from PR #378:
- DeepZoom collection/image source parsers (DZC/DZI XML)
- Tile cache, scheduler, and HTTP/file fetchers
- Controller (orchestrates loading), viewport (centered-fit geometry), renderer (draws tiles)
- 436 unit tests (animation tests excluded — no dependency on gestures/animations)
- Blazor sample page (Deep Zoom Preview) with testgrid DZI static asset
- MAUI sample page (Deep Zoom Preview) with testgrid DZI app-package asset
- Documentation: deep-zoom.md, deep-zoom-blazor.md, deep-zoom-maui.md
- Solution file updated to include DeepZoom test project
- DeepZoom added to MAUI ExtendedDemos and Blazor NavMenu

No gestures, animations, or custom controls included.
This is a minimal static preview system for gigapixel images.
Images render centered-fit (aspect ratio preserved, no cropping/stretching).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mattleibow

SkiaSharp.Extended.sln

@@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SkiaSharp.Extended.UI.Maui.
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SkiaSharpDemo.Blazor", "samples\SkiaSharpDemo.Blazor\SkiaSharpDemo.Blazor.csproj", "{B7E4C45C-5CAB-444E-B2D3-294151544256}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SkiaSharp.Extended.DeepZoom.Tests", "tests\SkiaSharp.Extended.DeepZoom.Tests\SkiaSharp.Extended.DeepZoom.Tests.csproj", "{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -53,6 +55,10 @@ Global
 		{B7E4C45C-5CAB-444E-B2D3-294151544256}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B7E4C45C-5CAB-444E-B2D3-294151544256}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B7E4C45C-5CAB-444E-B2D3-294151544256}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -64,6 +70,7 @@ Global
 		{2C67033A-2C49-4146-B942-9CDD2E0BA412} = {51B0C2C7-732B-4A5C-A4F2-55655D147866}
 		{4B4EC78C-33B5-456D-BD7D-4358D16272F4} = {5555F827-12DF-4D15-BF07-3A720FC2EF3F}
 		{B7E4C45C-5CAB-444E-B2D3-294151544256} = {51B0C2C7-732B-4A5C-A4F2-55655D147866}
+		{C8E5D3F1-2A47-4B89-AD16-7F3E2C1B9A5D} = {5555F827-12DF-4D15-BF07-3A720FC2EF3F}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {08D78153-5DD7-4C52-A348-46AA448B2CFC}

docs/docs/deep-zoom-blazor.md

@@ -0,0 +1,83 @@
+# Deep Zoom for Blazor
+
+Use `SKDeepZoomController` with a plain `SKCanvasView` to render Deep Zoom images in Blazor WebAssembly. There is no custom component — the page wires the services directly to the canvas.
+
+## Quick Start
+
+```razor
+@page "/deepzoom"
+@implements IDisposable
+@inject HttpClient Http
+@using SkiaSharp.Extended.DeepZoom
+
+<SKCanvasView @ref="_canvas"
+              OnPaintSurface="OnPaintSurface"
+              style="width: 100%; height: 600px; border: 1px solid #ccc;" />
+
+@code {
+    private SKCanvasView? _canvas;
+    private SKDeepZoomController? _controller;
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (!firstRender) return;
+
+        _controller = new SKDeepZoomController();
+        _controller.InvalidateRequired += OnInvalidateRequired;
+
+        var xml        = await Http.GetStringAsync("deepzoom/image.dzi");
+        var baseUrl    = new Uri(Http.BaseAddress!, "deepzoom/image_files/").ToString();
+        var tileSource = SKDeepZoomImageSource.Parse(xml, baseUrl);
+
+        _controller.Load(tileSource, new SKDeepZoomHttpTileFetcher(new HttpClient()));
+
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private void OnPaintSurface(SKPaintSurfaceEventArgs e)
+    {
+        if (_controller == null) return;
+
+        _controller.SetControlSize(e.Info.Width, e.Info.Height);
+        _controller.Update();
+        _controller.Render(e.Surface.Canvas);
+    }
+
+    private void OnInvalidateRequired(object? sender, EventArgs e)
+        => InvokeAsync(() => _canvas?.Invalidate());
+
+    public void Dispose()
+    {
+        if (_controller != null)
+        {
+            _controller.InvalidateRequired -= OnInvalidateRequired;
+            _controller.Dispose();
+        }
+    }
+}
+```
+
+## Serving Tile Assets
+
+Place `.dzi` and tile folder under `wwwroot`. In the project file, reference them as content:
+
+```xml
+<ItemGroup>
+    <Content Include="wwwroot\deepzoom\image.dzi" />
+    <Content Include="wwwroot\deepzoom\image_files\**" />
+</ItemGroup>
+```
+
+The `SKDeepZoomHttpTileFetcher` fetches each tile URL via `HttpClient`; tile URLs are constructed automatically from the base URL you supply to `SKDeepZoomImageSource.Parse`.
+
+## Rendering Behaviour
+
+- **Fit and center**: On load the controller calls `FitToView()` so the full image is visible and centered in the canvas. Neither cropping nor distortion occurs.
+- **Tile resolution**: `Update()` selects the pyramid level whose tile size best matches the physical pixel dimensions of the canvas. Only visible tiles are requested.
+- **Tile blending**: While high-resolution tiles are in-flight, parent-level tiles are upscaled and drawn as placeholders.
+
+## Related
+
+- [Deep Zoom overview](deep-zoom.md) — architecture, services, and API reference
+- [Deep Zoom for MAUI](deep-zoom-maui.md) — .NET MAUI integration
+

docs/docs/deep-zoom-maui.md

@@ -0,0 +1,129 @@
+# Deep Zoom for MAUI
+
+Use `SKDeepZoomController` with a plain `SKCanvasView` to render Deep Zoom images in .NET MAUI. There is no custom control — you wire the services directly to the canvas, which keeps the integration minimal and transparent.
+
+## Quick Start
+
+### XAML
+
+Add a `SKCanvasView` to your page:
+
+```xml
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:skia="clr-namespace:SkiaSharp.Views.Maui.Controls;assembly=SkiaSharp.Views.Maui.Controls"
+             x:Class="MyApp.DeepZoomPage"
+             Title="Deep Zoom">
+
+    <skia:SKCanvasView x:Name="canvas" PaintSurface="OnPaintSurface" />
+
+</ContentPage>
+```
+
+### Code-Behind
+
+```csharp
+using SkiaSharp;
+using SkiaSharp.Extended.DeepZoom;
+using SkiaSharp.Views.Maui;
+
+public partial class DeepZoomPage : ContentPage
+{
+    private readonly SKDeepZoomController _controller = new();
+
+    public DeepZoomPage()
+    {
+        InitializeComponent();
+        _controller.InvalidateRequired += (_, _) => canvas.InvalidateSurface();
+    }
+
+    protected override void OnAppearing()
+    {
+        base.OnAppearing();
+        LoadAsync();
+    }
+
+    protected override void OnDisappearing()
+    {
+        base.OnDisappearing();
+        _controller.Dispose();
+    }
+
+    private async void LoadAsync()
+    {
+        // Load a .dzi bundled as a MAUI app-package asset
+        using var stream = await FileSystem.OpenAppPackageFileAsync("image.dzi");
+        using var reader = new StreamReader(stream);
+        var xml = await reader.ReadToEndAsync();
+
+        var tileSource = SKDeepZoomImageSource.Parse(xml, "image_files/");
+        _controller.Load(tileSource, new AppPackageFetcher());
+        canvas.InvalidateSurface();
+    }
+
+    private void OnPaintSurface(object? sender, SKPaintSurfaceEventArgs e)
+    {
+        _controller.SetControlSize(e.Info.Width, e.Info.Height);
+        _controller.Update();
+        _controller.Render(e.Surface.Canvas);
+    }
+}
+```
+
+## App-Package Tile Fetcher
+
+When tiles are bundled as MAUI assets, implement `ISKDeepZoomTileFetcher` to read them via `FileSystem.OpenAppPackageFileAsync`:
+
+```csharp
+public sealed class AppPackageFetcher : ISKDeepZoomTileFetcher
+{
+    public async Task<SKBitmap?> FetchTileAsync(string url, CancellationToken ct = default)
+    {
+        try
+        {
+            using var stream = await FileSystem.OpenAppPackageFileAsync(url);
+            return SKBitmap.Decode(stream);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    public void Dispose() { }
+}
+```
+
+Include the `.dzi` and tile folder in the project file:
+
+```xml
+<ItemGroup>
+    <MauiAsset Include="Assets\image.dzi"               LogicalName="image.dzi" />
+    <MauiAsset Include="Assets\image_files\**"          LogicalName="image_files/%(RecursiveDir)%(Filename)%(Extension)" />
+</ItemGroup>
+```
+
+## HTTP Tile Fetcher
+
+For remote images, use the built-in `SKDeepZoomHttpTileFetcher`:
+
+```csharp
+var httpClient = new HttpClient();
+var fetcher    = new SKDeepZoomHttpTileFetcher(httpClient);
+
+var xml        = await httpClient.GetStringAsync("https://example.com/image.dzi");
+var tileSource = SKDeepZoomImageSource.Parse(xml, "https://example.com/image_files/");
+
+_controller.Load(tileSource, fetcher);
+```
+
+## Rendering Behaviour
+
+- **Fit and center**: On load the controller fits the full image into the canvas with `FitToView()`. The image is centered horizontally and vertically; neither cropping nor distortion occurs.
+- **Tile resolution**: `Update()` selects the pyramid level that best matches the physical pixel size of the canvas. Only tiles visible in the current viewport are fetched.
+- **Tile blending**: While high-resolution tiles load, lower-resolution tiles from the parent level are upscaled and composited as a placeholder (LOD blending).
+
+## Related
+
+- [Deep Zoom overview](deep-zoom.md) — architecture, services, and API reference
+- [Deep Zoom for Blazor](deep-zoom-blazor.md) — Blazor WebAssembly integration