Phase 7 Stream G — Address-space integration (NodeSourceKind + walker emits VirtualTag/ScriptedAlarm)

Per ADR-002, adds the Driver/Virtual/ScriptedAlarm discriminator to DriverAttributeInfo
so the DriverNodeManager's dispatch layer can route Read/Write/Subscribe to the right
runtime subsystem — drivers (unchanged), VirtualTagEngine (Phase 7 Stream B), or
ScriptedAlarmEngine (Phase 7 Stream C).

## Changes
- NodeSourceKind enum added to Core.Abstractions (Driver=0/Virtual=1/ScriptedAlarm=2).
- DriverAttributeInfo gains Source / VirtualTagId / ScriptedAlarmId parameters — all
  default so existing call sites (every driver) compile unchanged.
- EquipmentNamespaceContent gains VirtualTags + ScriptedAlarms optional collections.
- EquipmentNodeWalker emits:
  - Virtual-tag variables — Source=Virtual, VirtualTagId set, Historize flag honored
  - Scripted-alarm variables — Source=ScriptedAlarm, ScriptedAlarmId set, IsAlarm=true
    (triggers node-manager AlarmConditionState materialization)
  - Skips disabled virtual tags + scripted alarms

## Tests — 13/13 in EquipmentNodeWalkerTests (5 new)
- Virtual-tag variables carry Source=Virtual + VirtualTagId + Historize flag
- Scripted-alarm variables carry Source=ScriptedAlarm + IsAlarm=true + Boolean type
- Disabled rows skipped
- Null VirtualTags/ScriptedAlarms collections safe (back-compat for non-Phase-7 callers)
- Driver tags default Source=Driver (ensures no discriminator regression)

## Next
Stream G follow-up: DriverNodeManager dispatch (Read/Write/Subscribe routing by
NodeSourceKind), SealedBootstrap wiring of VirtualTagEngine + ScriptedAlarmEngine,
end-to-end integration test.

src/ZB.MOM.WW.OtOpcUa.Core/OpcUa/EquipmentNodeWalker.cs

@@ -87,6 +87,16 @@ public static class EquipmentNodeWalker
             .GroupBy(t => t.EquipmentId!, StringComparer.OrdinalIgnoreCase)
             .ToDictionary(g => g.Key, g => g.OrderBy(t => t.Name, StringComparer.Ordinal).ToList(), StringComparer.OrdinalIgnoreCase);
 
+        var virtualTagsByEquipment = (content.VirtualTags ?? [])
+            .Where(v => v.Enabled)
+            .GroupBy(v => v.EquipmentId, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.OrderBy(v => v.Name, StringComparer.Ordinal).ToList(), StringComparer.OrdinalIgnoreCase);
+
+        var scriptedAlarmsByEquipment = (content.ScriptedAlarms ?? [])
+            .Where(a => a.Enabled)
+            .GroupBy(a => a.EquipmentId, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.OrderBy(a => a.Name, StringComparer.Ordinal).ToList(), StringComparer.OrdinalIgnoreCase);
+
         foreach (var area in content.Areas.OrderBy(a => a.Name, StringComparer.Ordinal))
         {
             var areaBuilder = namespaceBuilder.Folder(area.Name, area.Name);
@@ -103,9 +113,17 @@ public static class EquipmentNodeWalker
                     AddIdentifierProperties(equipmentBuilder, equipment);
                     IdentificationFolderBuilder.Build(equipmentBuilder, equipment);
 
-                    if (!tagsByEquipment.TryGetValue(equipment.EquipmentId, out var equipmentTags)) continue;
-                    foreach (var tag in equipmentTags)
-                        AddTagVariable(equipmentBuilder, tag);
+                    if (tagsByEquipment.TryGetValue(equipment.EquipmentId, out var equipmentTags))
+                        foreach (var tag in equipmentTags)
+                            AddTagVariable(equipmentBuilder, tag);
+
+                    if (virtualTagsByEquipment.TryGetValue(equipment.EquipmentId, out var vTags))
+                        foreach (var vtag in vTags)
+                            AddVirtualTagVariable(equipmentBuilder, vtag);
+
+                    if (scriptedAlarmsByEquipment.TryGetValue(equipment.EquipmentId, out var alarms))
+                        foreach (var alarm in alarms)
+                            AddScriptedAlarmVariable(equipmentBuilder, alarm);
                 }
             }
         }
@@ -157,6 +175,55 @@ public static class EquipmentNodeWalker
     /// </summary>
     private static DriverDataType ParseDriverDataType(string raw) =>
         Enum.TryParse<DriverDataType>(raw, ignoreCase: true, out var parsed) ? parsed : DriverDataType.String;
+
+    /// <summary>
+    ///     Emit a <see cref="VirtualTag"/> row as a <see cref="NodeSourceKind.Virtual"/>
+    ///     variable node. <c>FullName</c> doubles as the UNS path Phase 7's VirtualTagEngine
+    ///     addresses its engine-side entries by. The <c>VirtualTagId</c> discriminator lets
+    ///     the DriverNodeManager dispatch Reads/Subscribes to the engine rather than any
+    ///     driver.
+    /// </summary>
+    private static void AddVirtualTagVariable(IAddressSpaceBuilder equipmentBuilder, VirtualTag vtag)
+    {
+        var attr = new DriverAttributeInfo(
+            FullName: vtag.VirtualTagId,
+            DriverDataType: ParseDriverDataType(vtag.DataType),
+            IsArray: false,
+            ArrayDim: null,
+            SecurityClass: SecurityClassification.FreeAccess,
+            IsHistorized: vtag.Historize,
+            IsAlarm: false,
+            WriteIdempotent: false,
+            Source: NodeSourceKind.Virtual,
+            VirtualTagId: vtag.VirtualTagId,
+            ScriptedAlarmId: null);
+        equipmentBuilder.Variable(vtag.Name, vtag.Name, attr);
+    }
+
+    /// <summary>
+    ///     Emit a <see cref="ScriptedAlarm"/> row as a <see cref="NodeSourceKind.ScriptedAlarm"/>
+    ///     variable node. The OPC UA Part 9 alarm-condition materialization happens at the
+    ///     node-manager level (which wires the concrete <c>AlarmConditionState</c> subclass
+    ///     per <see cref="ScriptedAlarm.AlarmType"/>); this walker provides the browse-level
+    ///     anchor + the <see cref="DriverAttributeInfo.IsAlarm"/> flag that triggers that
+    ///     materialization path.
+    /// </summary>
+    private static void AddScriptedAlarmVariable(IAddressSpaceBuilder equipmentBuilder, ScriptedAlarm alarm)
+    {
+        var attr = new DriverAttributeInfo(
+            FullName: alarm.ScriptedAlarmId,
+            DriverDataType: DriverDataType.Boolean,
+            IsArray: false,
+            ArrayDim: null,
+            SecurityClass: SecurityClassification.FreeAccess,
+            IsHistorized: false,
+            IsAlarm: true,
+            WriteIdempotent: false,
+            Source: NodeSourceKind.ScriptedAlarm,
+            VirtualTagId: null,
+            ScriptedAlarmId: alarm.ScriptedAlarmId);
+        equipmentBuilder.Variable(alarm.Name, alarm.Name, attr);
+    }
 }
 
 /// <summary>
@@ -170,4 +237,6 @@ public sealed record EquipmentNamespaceContent(
     IReadOnlyList<UnsArea> Areas,
     IReadOnlyList<UnsLine> Lines,
     IReadOnlyList<Equipment> Equipment,
-    IReadOnlyList<Tag> Tags);
+    IReadOnlyList<Tag> Tags,
+    IReadOnlyList<VirtualTag>? VirtualTags = null,
+    IReadOnlyList<ScriptedAlarm>? ScriptedAlarms = null);