Harden AppType startup: await render quiescence, dispose renderer, scope MapAppType

Addresses correctness concerns from PR review feedback:

- HybridHostPageRenderer.Render now awaits the host component's QuiescenceTask
  before serializing to HTML, so asynchronously-initialized host content (e.g.
  OnInitializedAsync) and its render-mode registrations are not dropped from the
  generated document. Mirrors the framework's own static HTML rendering.
- The static renderer is now disposed (on its dispatcher) after each host render
  instead of being leaked.
- MapAppType early-returns when AppType is null, leaving the legacy HostPage
  startup path completely untouched.

MacCatalyst device tests: 45 passed, 1 pre-existing skip (AppType host/mount,
dynamic head, @assets fingerprinting, and legacy paths all green).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 2ca68fe1-bef6-46a6-a0fd-17b7654cef34

Author: mattleibow

src/BlazorWebView/src/Maui/BlazorWebViewHandler.cs

@@ -82,6 +82,13 @@ public static void MapHostPage(BlazorWebViewHandler handler, IBlazorWebView webV
 		public static void MapAppType(BlazorWebViewHandler handler, IBlazorWebView webView)
 		{
 #if !(NETSTANDARD || !PLATFORM)
+			// Only views that opt into AppType need this mapper. When AppType is null the legacy
+			// HostPage startup path is left completely untouched (MapHostPage already handled it).
+			if (webView.AppType is null)
+			{
+				return;
+			}
+
 			// AppType provides a synthetic HostPage, so ensure the handler picks it up and attempts startup.
 			handler.HostPage = webView.HostPage;
 			handler.StartWebViewCoreIfPossible();

src/BlazorWebView/src/Maui/HybridHostPageRenderer.cs

@@ -75,16 +75,31 @@ public static HybridHostPageResult Render(
 			var resolvedAssets = assets ?? ResourceAssetCollection.Empty;
 
 			// Render on a thread-pool thread so the renderer's dispatcher never contends with the UI
-			// synchronization context. The render is synchronous (interactive components are replaced
-			// with static placeholders), so this completes without real blocking.
+			// synchronization context.
 			return Task.Run(() =>
 			{
 				var renderer = new HybridHostPageRenderer(services, loggerFactory, resolvedAssets);
-				return renderer.Dispatcher.InvokeAsync(() =>
+				return renderer.Dispatcher.InvokeAsync(async () =>
 				{
-					var rootComponent = renderer.BeginRenderingComponent(appComponentType, ParameterView.Empty);
-					var html = rootComponent.ToHtmlString();
-					return new HybridHostPageResult(html, renderer._registrations);
+					try
+					{
+						var rootComponent = renderer.BeginRenderingComponent(appComponentType, ParameterView.Empty);
+
+						// Wait for the component tree to finish rendering - including any asynchronous
+						// initialization (for example OnInitializedAsync) - before serializing, otherwise
+						// async host content (and its render-mode registrations) could be omitted from the
+						// document. This mirrors how the framework's own static HTML rendering awaits quiescence.
+						await rootComponent.QuiescenceTask.ConfigureAwait(false);
+
+						var html = rootComponent.ToHtmlString();
+						return new HybridHostPageResult(html, renderer._registrations);
+					}
+					finally
+					{
+						// Dispose on the renderer's dispatcher (required by Renderer) to release the
+						// component tree and avoid leaking the renderer per host render.
+						renderer.Dispose();
+					}
 				});
 			}).GetAwaiter().GetResult();
 		}