fix(store-and-forward): resolve S&F delivery + replication wiring (3 Critical findings)

Resolves StoreAndForward-001, ExternalSystemGateway-001, NotificationService-001
— one systemic gap where buffered messages were persisted but never delivered,
and the active node never replicated its buffer to the standby.

Delivery handlers (ExternalSystemGateway-001 / NotificationService-001):
- AkkaHostedService registers delivery handlers for the ExternalSystem,
  CachedDbWrite and Notification categories after StoreAndForwardService starts;
  each resolves its scoped consumer in a fresh DI scope.
- ExternalSystemClient, DatabaseGateway and NotificationDeliveryService each
  gain a DeliverBufferedAsync method: re-resolve the target and re-attempt
  delivery, returning true/false/throwing per the transient-vs-permanent contract.
- EnqueueAsync gains an attemptImmediateDelivery flag; CachedCallAsync and
  NotificationDeliveryService.SendAsync pass false (they already attempted
  delivery themselves) so registering a handler does not dispatch twice.

Replication (StoreAndForward-001):
- ReplicationService is injected into StoreAndForwardService; a new BufferAsync
  helper replicates every enqueue, and successful-retry removes and parks are
  replicated too. Fire-and-forget, no-op when replication is disabled.

Tests: StoreAndForwardReplicationTests (Add/Remove/Park observed),
attemptImmediateDelivery behaviour, and DeliverBufferedAsync paths for each
consumer. Full solution builds; StoreAndForward/ExternalSystemGateway/
NotificationService suites green.

src/ScadaLink.Host/Actors/AkkaHostedService.cs

@@ -344,6 +344,42 @@ akka {{
             // any actor or HTTP handler touches the service.
             storeAndForwardService.StartAsync().GetAwaiter().GetResult();
 
+            // Register the store-and-forward delivery handlers so buffered
+            // ExternalSystem calls, cached DB writes and notifications are actually
+            // delivered by the retry sweep. Without this, every buffered message is
+            // persisted but never delivered. Each handler resolves its scoped consumer
+            // service in a fresh DI scope — the sweep runs on a timer thread, outside
+            // any request scope.
+            storeAndForwardService.RegisterDeliveryHandler(
+                ScadaLink.Commons.Types.Enums.StoreAndForwardCategory.ExternalSystem,
+                async msg =>
+                {
+                    using var scope = _serviceProvider.CreateScope();
+                    return await scope.ServiceProvider
+                        .GetRequiredService<ScadaLink.ExternalSystemGateway.ExternalSystemClient>()
+                        .DeliverBufferedAsync(msg);
+                });
+            storeAndForwardService.RegisterDeliveryHandler(
+                ScadaLink.Commons.Types.Enums.StoreAndForwardCategory.CachedDbWrite,
+                async msg =>
+                {
+                    using var scope = _serviceProvider.CreateScope();
+                    return await scope.ServiceProvider
+                        .GetRequiredService<ScadaLink.ExternalSystemGateway.DatabaseGateway>()
+                        .DeliverBufferedAsync(msg);
+                });
+            storeAndForwardService.RegisterDeliveryHandler(
+                ScadaLink.Commons.Types.Enums.StoreAndForwardCategory.Notification,
+                async msg =>
+                {
+                    using var scope = _serviceProvider.CreateScope();
+                    return await scope.ServiceProvider
+                        .GetRequiredService<ScadaLink.NotificationService.NotificationDeliveryService>()
+                        .DeliverBufferedAsync(msg);
+                });
+            _logger.LogInformation(
+                "Store-and-forward delivery handlers registered (ExternalSystem, CachedDbWrite, Notification)");
+
             var parkedMessageHandler = _actorSystem.ActorOf(
                 Props.Create(() => new ParkedMessageHandlerActor(
                     storeAndForwardService, _nodeOptions.SiteId!)),