feat(notif): NotificationOutboxActor + CentralAuditWriter wired (#23 M4)

M4 Bundle B (B1) — add the central-only ICentralAuditWriter implementation
and inject it into NotificationOutboxActor so subsequent tasks (B2/B3) can
route attempt + terminal lifecycle events through the direct-write audit path.

- CentralAuditWriter: thin wrapper around IAuditLogRepository.InsertIfNotExistsAsync;
  scope-per-call (matches AuditLogIngestActor / NotificationOutboxActor pattern);
  stamps IngestedAtUtc; swallows all internal failures (alog.md §13).
- Registered as a singleton in AddAuditLog.
- NotificationOutboxActor ctor takes ICentralAuditWriter (validated non-null).
- Host wiring resolves the writer once from the root provider and passes it
  into the singleton's Props.Create call.
- Existing TestKit fixtures updated with a NoOpCentralAuditWriter helper so
  tests that don't exercise audit emission still compile and pass.

tests/ScadaLink.NotificationOutbox.Tests/NotificationOutboxActorAuditInjectionTests.cs

@@ -0,0 +1,79 @@
+using Akka.Actor;
+using Akka.TestKit.Xunit2;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using ScadaLink.Commons.Entities.Audit;
+using ScadaLink.Commons.Entities.Notifications;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Interfaces.Services;
+
+namespace ScadaLink.NotificationOutbox.Tests;
+
+/// <summary>
+/// M4 Bundle B (B1) — verifies <see cref="NotificationOutboxActor"/> accepts an
+/// <see cref="ICentralAuditWriter"/> at construction so subsequent bundle tasks
+/// (B2/B3) can route attempt + terminal lifecycle events through the central
+/// direct-write audit path.
+/// </summary>
+public class NotificationOutboxActorAuditInjectionTests : TestKit
+{
+    private static IServiceProvider BuildEmptyProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddScoped(_ => Substitute.For<INotificationOutboxRepository>());
+        services.AddScoped(_ => Substitute.For<INotificationRepository>());
+        return services.BuildServiceProvider();
+    }
+
+    /// <summary>
+    /// Inline NoOp writer that records calls — used to assert later tasks emit
+    /// events without depending on a concrete CentralAuditWriter.
+    /// </summary>
+    private sealed class RecordingCentralAuditWriter : ICentralAuditWriter
+    {
+        public List<AuditEvent> Events { get; } = new();
+
+        public Task WriteAsync(AuditEvent evt, CancellationToken ct = default)
+        {
+            lock (Events)
+            {
+                Events.Add(evt);
+            }
+            return Task.CompletedTask;
+        }
+    }
+
+    [Fact]
+    public void Actor_ConstructedWith_ICentralAuditWriter_NoException()
+    {
+        var writer = new RecordingCentralAuditWriter();
+        // Long dispatch interval so PreStart's timer never fires during the test.
+        var options = new NotificationOutboxOptions { DispatchInterval = TimeSpan.FromHours(1) };
+
+        var actor = Sys.ActorOf(Props.Create(() => new NotificationOutboxActor(
+            BuildEmptyProvider(),
+            options,
+            writer,
+            NullLogger<NotificationOutboxActor>.Instance)));
+
+        Assert.NotNull(actor);
+        // No event has been emitted yet — the writer is purely injected at this stage.
+        lock (writer.Events)
+        {
+            Assert.Empty(writer.Events);
+        }
+    }
+
+    [Fact]
+    public void Actor_NullAuditWriter_Throws()
+    {
+        var options = new NotificationOutboxOptions { DispatchInterval = TimeSpan.FromHours(1) };
+
+        Assert.Throws<ArgumentNullException>(() => new NotificationOutboxActor(
+            BuildEmptyProvider(),
+            options,
+            auditWriter: null!,
+            NullLogger<NotificationOutboxActor>.Instance));
+    }
+}