fix(opcuaserver): UNS reference nodes repair on backing-tag historian/shape edits

Adversarial review of 9f68f272 (classifier: non-alarm raw-tag deltas became
surgical) found stale UNS inheritance after a surgical raw edit. Editing a raw
tag's IsHistorized / HistorianTagname / IsArray / ArrayLength left every
referencing UNS node STALE: none of those fields were on UnsReferenceVariable,
so no coincident UnsReferenceDelta fired; the applier updated the raw node in
place; and EnsureVariable early-returns on an existing node. Consequences:
HistoryRead through the UNS NodeId served a different series than through the
raw NodeId (breaking the documented dual-registration invariant), a
de-historized tag kept serving history via UNS, and a scalar->array flip left
the UNS mirror scalar AND writable (bypassing the array read-only write gate).

UnsReferenceVariable now carries Backing{IsHistorized,HistorianTagname,IsArray,
ArrayLength}, copied from the backing tag's TagConfigIntent at compose time, so
record equality makes the reference Changed in the SAME plan. Both deltas are
non-rebuild kinds, so the existing machinery repairs the mirror surgically:
remove-previous in Apply, recreate in MaterialiseUnsReferences. That pass now
reads the four values from the RECORD (the single truth the planner diffed)
instead of a rawByPath back-lookup, preserving historian resolution exactly
(blank override => BackingRawPath, which is the backing tag's NodeId).

The artifact-decode seam needs no change: DeploymentArtifact.BuildRawAndUnsSubtrees
drives AddressSpaceComposer.Compose verbatim, which is what guarantees byte-parity.
The classifier needs no change either (a UnsReferenceDelta never forces Rebuild);
its comment now records why.

Also from the same review: a three-place-contract comment on RawTagPlan's
hand-written Equals naming its two downstream consumers, plus classifier pins for
the .Any(!eligible) quantifier, an ArrayLength-only delta, and an
alarm-content-only delta.

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceApplier.cs

@@ -828,35 +828,36 @@ public sealed class AddressSpaceApplier
     ///     parented under its equipment folder (the logical <see cref="UnsReferenceVariable.EquipmentId"/> node
     ///     <see cref="MaterialiseHierarchy"/> already created), THEN an <c>Organizes</c> reference
     ///     UNS→Raw to its backing raw node. The UNS node inherits DataType / writable / array shape / historian
-    ///     tagname from its backing RAW tag (looked up by <see cref="UnsReferenceVariable.BackingRawPath"/>), so a
-    ///     historized raw tag's UNS reference registers the SAME tagname (both NodeIds → one tagname → HistoryRead
-    ///     works against either). The UNS node binds NO driver — the driver publish path fans values to it (WP3
-    ///     runtime binding). Every sink call passes <see cref="AddressSpaceRealm.Uns"/> / the Organizes edge
-    ///     passes both realms EXPLICITLY. Idempotent.
+    ///     tagname from its backing RAW tag, so a historized raw tag's UNS reference registers the SAME tagname
+    ///     (both NodeIds → one tagname → HistoryRead works against either). The UNS node binds NO driver — the
+    ///     driver publish path fans values to it (WP3 runtime binding). Every sink call passes
+    ///     <see cref="AddressSpaceRealm.Uns"/> / the Organizes edge passes both realms EXPLICITLY. Idempotent.
+    ///     <para><b>The inherited values are read from the <see cref="UnsReferenceVariable"/> RECORD, not
+    ///     re-looked-up from <see cref="AddressSpaceComposition.RawTags"/> by RawPath.</b> The record is the
+    ///     single truth: the composer copies them off the backing tag's <c>TagConfigIntent</c> at compose time
+    ///     (both compose seams, byte-parity), and having them ON the record is what makes a raw-side historian /
+    ///     shape edit produce the coincident <c>UnsReferenceDelta</c> that drives this node's repair
+    ///     (remove-previous in <c>Apply</c>, recreate here). A back-lookup would re-introduce the split the
+    ///     2026-08-15 review found: a record that says one thing and a materialised node built from another.</para>
     /// </summary>
-    /// <param name="composition">The composition carrying the UNS reference variables + Raw tags (for inherited shape).</param>
+    /// <param name="composition">The composition carrying the UNS reference variables.</param>
     /// <returns>The count of swallowed sink failures in this pass.</returns>
     public int MaterialiseUnsReferences(AddressSpaceComposition composition)
     {
         ArgumentNullException.ThrowIfNull(composition);
         if (composition.UnsReferenceVariables.Count == 0) return 0;
 
-        // Backing raw tag shape/historian by RawPath — a UNS reference inherits these so its node matches the
-        // raw node it mirrors (a historized raw tag registers the SAME tagname on the UNS node for HistoryRead).
-        var rawByPath = new Dictionary<string, RawTagPlan>(StringComparer.Ordinal);
-        foreach (var t in composition.RawTags) rawByPath[t.NodeId] = t;
-
         var failed = 0;
         foreach (var v in composition.UnsReferenceVariables)
         {
-            var backing = rawByPath.GetValueOrDefault(v.BackingRawPath);
-            var isArray = backing?.IsArray ?? false;
-            uint? arrayLength = backing?.ArrayLength;
+            var isArray = v.BackingIsArray;
+            uint? arrayLength = v.BackingArrayLength;
             // A UNS reference to a historized raw tag registers the SAME effective historian tagname (override
-            // else the backing RawPath) so HistoryRead resolves against the UNS NodeId too. The mux ref stays
-            // single (keyed by RawPath) — FeedHistorizedRefs emits raw refs only.
-            string? historianTagname = backing is { IsHistorized: true }
-                ? (string.IsNullOrWhiteSpace(backing.HistorianTagname) ? backing.NodeId : backing.HistorianTagname)
+            // else the backing RawPath — BackingRawPath IS the backing raw tag's NodeId) so HistoryRead resolves
+            // against the UNS NodeId too. The mux ref stays single (keyed by RawPath) — FeedHistorizedRefs emits
+            // raw refs only.
+            string? historianTagname = v.BackingIsHistorized
+                ? (string.IsNullOrWhiteSpace(v.BackingHistorianTagname) ? v.BackingRawPath : v.BackingHistorianTagname)
                 : null;
             var writable = v.Writable && !isArray;
             if (!SafeEnsureVariable(v.NodeId, v.EquipmentId, v.EffectiveName, v.DataType, writable, AddressSpaceRealm.Uns, historianTagname, isArray, arrayLength))