perf(templates): descendant reconcile loads only the subtree + chain (ScadaBridge#86)

TemplateService.ReconcileDescendantsAsync - run after every base member
add/update/delete, template and native-alarm-source alike - loaded the whole
tracked template graph (every template, member and script body) on each call,
which after #66 was the dominant cost of those paths. It now calls the new
ITemplateEngineRepository.GetTemplateReconcileClosureAsync: the same tracked,
fully-included shape as GetAllTemplatesAsync, restricted to the edited
template's derived subtree plus its own inheritance chain. The reconcile is
inheritance-only (TemplateInheritanceResolver never follows compositions) and
every descendant's chain runs through the edited template, so that set is
everything it reads.

The walk (Commons TemplateReconcileClosure, the descendant-direction twin of
#66's TemplateAnalysisClosure) loads one children batch per subtree depth and
one batch per ancestor level, terminates on parent cycles and stops at
dangling parents. A template with no children - the common case - costs one
empty probe and loads nothing.

Evidence:
- TemplateReconcileClosureTests: for every template of a graph with a deep
  subtree, an ancestor above the edited template, a composed module,
  look-alike unrelated trees, a parent cycle and a dangling parent, the
  closure-backed reconcile issues exactly the writes (add/update/delete,
  audit, save) of the old whole-graph reconcile, and the resolver answers
  identically for every descendant. Fails with the old service (whole-graph
  load wired to throw) and with the ancestor walk removed (mutation-checked).
- TemplateReconcileClosureRepositoryTests (SQLite, recorded SQL): 5 templates
  / 10 attributes instead of 47 / 94, tracked with script bodies; a leaf costs
  one probe query and tracks nothing.
- TemplateServiceTests: attribute add + update propagate two levels down with
  GetAllTemplatesAsync wired to throw; existing propagation tests now run
  against the closure via ServeReconcileClosureFromFullGraph.

ResyncInheritedMembersAsync (operator action) still reads the whole graph.

Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV

tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/AnalysisClosureMock.cs

@@ -37,4 +37,33 @@ internal static class AnalysisClosureMock
                     ct);
             });
     }
+
+    /// <summary>
+    /// Gitea #86: the descendant reconcile now asks for the reconcile closure (derived subtree +
+    /// the template's chain) instead of <c>GetAllTemplatesAsync</c>. Wires it to run the real
+    /// closure walk over whatever the full tracked-graph setup returns, so every existing
+    /// propagation scenario exercises the service against the reduced set.
+    /// </summary>
+    /// <param name="repoMock">The repository mock.</param>
+    /// <param name="closureRequests">Optional sink recording each requested closure root.</param>
+    public static void ServeReconcileClosureFromFullGraph(
+        this Mock<ITemplateEngineRepository> repoMock,
+        List<int>? closureRequests = null)
+    {
+        async Task<IReadOnlyList<Template>> All(CancellationToken token) =>
+            await repoMock.Object.GetAllTemplatesAsync(token) ?? Array.Empty<Template>();
+
+        repoMock
+            .Setup(r => r.GetTemplateReconcileClosureAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .Returns((int templateId, CancellationToken ct) =>
+            {
+                closureRequests?.Add(templateId);
+                return TemplateReconcileClosure.CollectAsync(
+                    templateId,
+                    async (parentIds, token) => (await All(token))
+                        .Where(t => t.ParentTemplateId is int p && parentIds.Contains(p)).ToList(),
+                    async (ids, token) => (await All(token)).Where(t => ids.Contains(t.Id)).ToList(),
+                    ct);
+            });
+    }
 }