feat(host,runtime): #108 Host DI bindings — OPC UA server + deferred sink

Wires the OPC UA SDK into the fused Host's lifecycle on driver-role
nodes + spawns OpcUaPublishActor with the proper sink/publisher/dbFactory/
applier resolution. The full read+write data path is now live in
production: Deploy → DriverHost → OpcUaPublish → SDK NodeManager →
subscribed OPC UA clients.

DeferredAddressSpaceSink (Commons.OpcUa):
  - Thread-safe wrapper IOpcUaAddressSpaceSink that delegates to an
    inner sink swapped in at runtime. Needed because Akka actors
    resolve the sink at construction time, but the production sink
    (SdkAddressSpaceSink wrapping OtOpcUaNodeManager) only exists
    after the SDK StandardServer has started.
  - Defaults to NullOpcUaAddressSpaceSink so calls before swap are
    safe; SetSink(null) reverts (for graceful shutdown).

OtOpcUaServerHostedService (Host.OpcUa):
  - IHostedService that owns the OPC UA SDK lifecycle. Reads
    OpcUaApplicationHostOptions from the 'OpcUa' config section,
    creates an OtOpcUaSdkServer, boots it through OpcUaApplicationHost,
    then swaps a real SdkAddressSpaceSink into the DeferredAddressSpaceSink
    singleton.
  - SDK boot failure is logged + non-fatal — the rest of the host
    (admin UI, driver actors) keeps running. Stop reverts to null sink.

WithOtOpcUaRuntimeActors (Runtime):
  - Now spawns OpcUaPublishActor (new actor) + threads its ActorRef
    into DriverHostActor's Props so successful applies trigger the
    address-space rebuild pipeline.
  - Phase7Applier is constructed here from the resolved sink + a
    logger; OpcUaPublishActor takes both.
  - Prepends the opcua-synchronized-dispatcher HOCON so the extension
    is self-contained — consumers (Host, tests) don't need to redeclare
    the dispatcher block.
  - New OpcUaPublishActorKey + OpcUaPublishActorName for actor-registry
    resolution.
  - AddOtOpcUaRuntime now also TryAddSingleton's NullOpcUaAddressSpaceSink
    + NullServiceLevelPublisher so admin-only nodes (or tests that
    don't bind the Deferred sink) stay safe.

Host.Program.cs (driver-role only):
  - Binds DeferredAddressSpaceSink as singleton + as IOpcUaAddressSpaceSink
  - AddHostedService<OtOpcUaServerHostedService>()

Tests: OpcUaServer 24 -> 28 (+4 DeferredAddressSpaceSink unit tests),
Runtime 69 -> 69 (existing ServiceCollectionExtensionsTests extended
to verify the new mux + publish actor registration).

All 6 v2 test suites green: 177 tests passing.

Closes #108. Engine-wiring is now production-bound end-to-end on
driver-role nodes — Deploy reaches real OPC UA Variable nodes that
subscribed clients see.

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/ServiceCollectionExtensions.cs

@@ -3,13 +3,18 @@ using Akka.Hosting;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using ZB.MOM.WW.OtOpcUa.Commons.Interfaces;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Configuration;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 using ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian;
+using ZB.MOM.WW.OtOpcUa.OpcUaServer;
 using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
 using ZB.MOM.WW.OtOpcUa.Runtime.Health;
 using ZB.MOM.WW.OtOpcUa.Runtime.Historian;
+using ZB.MOM.WW.OtOpcUa.Runtime.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Runtime.VirtualTags;
 
 namespace ZB.MOM.WW.OtOpcUa.Runtime;
@@ -22,6 +27,7 @@ public static class ServiceCollectionExtensions
     public const string DbHealthProbeActorName = "db-health";
     public const string HistorianAdapterActorName = "historian-adapter";
     public const string DependencyMuxActorName = "dependency-mux";
+    public const string OpcUaPublishActorName = "opcua-publish";
 
     /// <summary>
     /// Registers shared runtime services. Currently binds <see cref="IAlarmHistorianSink"/>
@@ -33,6 +39,8 @@ public static class ServiceCollectionExtensions
     {
         services.TryAddSingleton<IAlarmHistorianSink>(NullAlarmHistorianSink.Instance);
         services.TryAddSingleton<IDriverFactory>(NullDriverFactory.Instance);
+        services.TryAddSingleton<IOpcUaAddressSpaceSink>(NullOpcUaAddressSpaceSink.Instance);
+        services.TryAddSingleton<IServiceLevelPublisher>(NullServiceLevelPublisher.Instance);
         return services;
     }
 
@@ -54,6 +62,19 @@ public static class ServiceCollectionExtensions
     /// </summary>
     public static AkkaConfigurationBuilder WithOtOpcUaRuntimeActors(this AkkaConfigurationBuilder builder)
     {
+        // Production cluster HOCON (akka.conf) carries this dispatcher block, but consumers that
+        // bootstrap their own HOCON (e.g. ServiceCollectionExtensionsTests) wouldn't pick it up
+        // — OpcUaPublishActor.Props pins itself to opcua-synchronized-dispatcher and Akka throws
+        // ConfigurationException if it doesn't exist. Prepend a fallback so the runtime extension
+        // is self-contained.
+        builder.AddHocon(@"
+            opcua-synchronized-dispatcher {
+                type = ""PinnedDispatcher""
+                executor = ""thread-pool-executor""
+                throughput = 1
+            }
+        ", HoconAddMode.Prepend);
+
         builder.WithActors((system, registry, resolver) =>
         {
             var dbFactory = resolver.GetService<IDbContextFactory<OtOpcUaConfigDbContext>>();
@@ -61,6 +82,9 @@ public static class ServiceCollectionExtensions
             // Fallback to Null* if AddOtOpcUaRuntime wasn't called (e.g., test harnesses).
             var historianSink = resolver.GetService<IAlarmHistorianSink>() ?? NullAlarmHistorianSink.Instance;
             var driverFactory = resolver.GetService<IDriverFactory>() ?? NullDriverFactory.Instance;
+            var addressSpaceSink = resolver.GetService<IOpcUaAddressSpaceSink>() ?? NullOpcUaAddressSpaceSink.Instance;
+            var serviceLevel = resolver.GetService<IServiceLevelPublisher>() ?? NullServiceLevelPublisher.Instance;
+            var loggerFactory = resolver.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
 
             var dbHealth = system.ActorOf(
                 DbHealthProbeActor.Props(dbFactory),
@@ -72,10 +96,25 @@ public static class ServiceCollectionExtensions
             var mux = system.ActorOf(DependencyMuxActor.Props(), DependencyMuxActorName);
             registry.Register<DependencyMuxActorKey>(mux);
 
+            // OPC UA publish actor — pinned dispatcher, owns the address-space side of the
+            // pipeline. Phase7Applier is constructed here so the actor + applier share the
+            // same sink reference (when DeferredAddressSpaceSink swaps later, both see it).
+            var applier = new Phase7Applier(addressSpaceSink, loggerFactory.CreateLogger<Phase7Applier>());
+            var publishActor = system.ActorOf(
+                OpcUaPublishActor.Props(
+                    sink: addressSpaceSink,
+                    serviceLevel: serviceLevel,
+                    localNode: roleInfo.LocalNode,
+                    dbFactory: dbFactory,
+                    applier: applier),
+                OpcUaPublishActorName);
+            registry.Register<OpcUaPublishActorKey>(publishActor);
+
             var driverHost = system.ActorOf(
                 DriverHostActor.Props(dbFactory, roleInfo.LocalNode, coordinator: null,
                     driverFactory: driverFactory, localRoles: roleInfo.LocalRoles,
-                    dependencyMux: mux),
+                    dependencyMux: mux,
+                    opcUaPublishActor: publishActor),
                 DriverHostActorName);
             registry.Register<DriverHostActorKey>(driverHost);
 
@@ -94,3 +133,4 @@ public sealed class DriverHostActorKey { }
 public sealed class DbHealthProbeActorKey { }
 public sealed class HistorianAdapterActorKey { }
 public sealed class DependencyMuxActorKey { }
+public sealed class OpcUaPublishActorKey { }