feat(blur): a privacy blur layer for the Live scene — boxes and circles over the desktop

Creator request 2026-11-01: a layer that hides part of the desktop from viewers. Box or circle,
drag/resize like any layer, one strength slider, several allowed.

**Z-order is policy, not preference.** `AddSource` inserts a blur directly above the background
and therefore below the brand logo, and `OnSceneElementsReordered` pushes any blur that ends up
above the brand back down. Nothing else in the app can move it into the brand's way.

**Overlap = the strongest single blur, never a stack.** `SceneCompositor.ApplyBlurLayers` collects
every visible blur the first time one is reached in the z-order, sorts them strongest-first, and
shares one coverage map: a pixel already covered by a stronger blur is skipped. Blurring
back-to-front would have produced something stronger than any slider setting allows, which is
exactly what was ruled out.

**One blur curve, shared with the webcam.** `RegionBlur` carries the constants the webcam blur
already used — downscale 4, radius 1–6 downscaled px, `RadiusFor(strength)` — and
`BackgroundEffectProcessor` now delegates to it instead of holding its own copy. The layer's
slider is the same 0–1 scale with the same 0.5 default, so "half strength" means the same blur in
both features. Cost is proportional to the blur's own rect, not the frame.

**Live scene only**, enforced in `AddSource` as well as the (+) menu (`CanAddBlur`), so a stale
menu item or a scripted call cannot plant one on BRB. `ElementKind.Dynamic`, so it is never baked
into the static base and every render path gets it — pump, preview, thumbnails, scene dump.

Persistence: `Source.BlurAmount` column + migration; shape rides the existing `ClipShape`.
Properties panel: Box | Circle plus the strength slider, gated on `IsBlurSelected`.

4 tests: outside the mask is byte-identical, inside loses its hard edges, a circle leaves its
box corners alone, and two identical stacked blurs equal one (the coverage map). Release builds
at 0 warnings.

Services/BackgroundEffects/BackgroundEffectProcessor.cs

@@ -1,5 +1,6 @@
 using ytLive.Helpers;
 using ytLive.Models;
+using ytLive.Services.Compositor;
 
 namespace ytLive.Services.BackgroundEffects;
 
@@ -28,16 +29,12 @@ public sealed class BackgroundEffectProcessor
 {
     public const double DefaultStrength = 0.5;
 
-    /// <summary>The background is blurred at 1/<see cref="BlurDownscale"/> resolution and
-    /// upsampled while blending — a strong blur at a fraction of the cost.</summary>
-    internal const int BlurDownscale = 4;
-
-    /// <summary>Box-blur radius (in downscaled pixels) at strength 0 and 1. The maximum was halved
-    /// from 12 (2026-10-09): the creator found full range too heavy — the old max spread ≈48 full
-    /// px. The established tools blur far less: StreamFX defaults its Box blur size to 5 and its
-    /// author stops downscale-based blurs around 8 px.</summary>
-    internal const int MinBlurRadius = 1;
-    internal const int MaxBlurRadius = 6;
+    /// <summary>Shared with the privacy blur layer (Services/Compositor/RegionBlur): one radius
+    /// curve for both, so a strength means the same thing everywhere. The maximum was halved from
+    /// 12 on 2026-10-09 — full range was too heavy, and the established tools blur far less.</summary>
+    internal const int BlurDownscale = RegionBlur.Downscale;
+    internal const int MinBlurRadius = RegionBlur.MinRadius;
+    internal const int MaxBlurRadius = RegionBlur.MaxRadius;
 
     private readonly IPersonSegmenter _segmenter;
     private bool _loggedFailure;
@@ -218,11 +215,7 @@ public sealed class BackgroundEffectProcessor
     /// <summary>Blur radius in downscaled pixels for a strength. Quadratic (s²), not linear, so the
     /// default 0.5 stays gentle (2 small px ≈ ~8–10 full px of perceived spread, ~3× lighter than
     /// the old linear 6) while only the top of the slider approaches the full range.</summary>
-    internal static int BlurRadius(double strength)
-    {
-        var s = Math.Clamp(strength, 0, 1);
-        return (int)Math.Round(MinBlurRadius + (MaxBlurRadius - MinBlurRadius) * s * s);
-    }
+    internal static int BlurRadius(double strength) => RegionBlur.RadiusFor(strength);
 
     /// <summary>Row-parallel pixel loops, capped so the effect worker can't starve the compositor
     /// and encoder threads.</summary>