feat(notification-outbox): async Notify.Send with status handle

Notify.To(list).Send(subject,body) now generates a NotificationId GUID,
enqueues a Notification-category message into the site Store-and-Forward
Engine, and returns the NotificationId immediately (Task<string>). The
NotificationId is the single idempotency key end-to-end: it is the S&F
message Id, it is carried inside the buffered NotificationSubmit payload,
and it is the id the forwarder submits to central.

NotificationForwarder now deserializes the buffered payload as a
NotificationSubmit and reads NotificationId from it (re-stamping only the
site-owned SourceSiteId / SourceInstanceId), instead of deriving the id
from StoreAndForwardMessage.Id.

Adds NotifyHelper.Status(id): queries central via the site communication
actor; reports the site-local Forwarding state while the notification is
still buffered at the site, maps central's response when found, and
Unknown otherwise. Adds a NotificationDeliveryStatus record.

SiteCommunicationActor gains a NotificationStatusQuery forwarding handler
mirroring NotificationSubmit. StoreAndForwardService.EnqueueAsync gains an
optional messageId parameter and exposes GetMessageByIdAsync.

src/ScadaLink.StoreAndForward/StoreAndForwardService.cs

@@ -149,6 +149,13 @@ public class StoreAndForwardService
     /// When <c>false</c>, the caller has already made its own delivery attempt and the
     /// message is buffered directly for the retry sweep (the handler is not invoked here).
     /// </param>
+    /// <param name="messageId">
+    /// An explicit, caller-supplied message id. <c>null</c> (the default) makes the
+    /// service mint a fresh GUID. The Notification Outbox enqueue path supplies its own
+    /// id so the script-generated <c>NotificationId</c> is the single idempotency key —
+    /// it is the buffered row's <see cref="StoreAndForwardMessage.Id"/>, it is carried
+    /// inside the payload, and it is the id the forwarder submits to central.
+    /// </param>
     public async Task<StoreAndForwardResult> EnqueueAsync(
         StoreAndForwardCategory category,
         string target,
@@ -156,11 +163,12 @@ public class StoreAndForwardService
         string? originInstanceName = null,
         int? maxRetries = null,
         TimeSpan? retryInterval = null,
-        bool attemptImmediateDelivery = true)
+        bool attemptImmediateDelivery = true,
+        string? messageId = null)
     {
         var message = new StoreAndForwardMessage
         {
-            Id = Guid.NewGuid().ToString("N"),
+            Id = messageId ?? Guid.NewGuid().ToString("N"),
             Category = category,
             Target = target,
             PayloadJson = payloadJson,
@@ -430,6 +438,17 @@ public class StoreAndForwardService
         return await _storage.GetMessageCountByOriginInstanceAsync(instanceName);
     }
 
+    /// <summary>
+    /// Notification Outbox: looks up a buffered message by its id, or <c>null</c> if it
+    /// is not (or no longer) in the buffer. <c>Notify.Status</c> uses this to detect a
+    /// notification still in transit at the site — central reports it not-found while
+    /// the S&amp;F buffer still holds it, which is the site-local <c>Forwarding</c> state.
+    /// </summary>
+    public async Task<StoreAndForwardMessage?> GetMessageByIdAsync(string messageId)
+    {
+        return await _storage.GetMessageByIdAsync(messageId);
+    }
+
     /// <summary>
     /// WP-14: Raises the S&amp;F activity notification. StoreAndForward-009: the
     /// delegate is snapshotted (so a concurrent unsubscribe cannot NRE) and every