feat(mtconnect): IReadable via /current, ordered per-ref snapshots (Task 10)

One deadline-bounded /current per batch, answered out of that one whole-device
document: N references cost one round-trip, one snapshot each, in request order,
duplicates included.

DEVIATION (deliberate, from the plan's implied shared-index write): the response
is indexed into a PER-CALL snapshot index, never into the driver's shared
observation index. That index is written by Task 11's /sample pump and is
last-write-wins with no timestamp arbitration; a read folding its /current into
it would be a second writer racing the first, and /current is frequently the
OLDER document (the Agent composes it while the pump's newer delta is in
flight). Losing that race rolls a subscribed value backwards and leaves it there
until the data item next changes. Both paths coerce through the same
MTConnectObservationIndex logic, so a read and a subscription report a given
observation identically -- the read path is simply a pure function of
(document, authored tags).

Failure posture is the inverse of InitializeAsync: nothing but genuine caller
cancellation crosses the capability boundary. Unreachable Agent / blown deadline
/ unusable answer => every ref codes BadCommunicationError and the driver
degrades (never downgrading Faulted); no client at all (pre-initialize, faulted,
post-shutdown) => BadNotConnected with health untouched. The index's
BadWaitingForInitialData / BadNodeIdUnknown / BadNoCommunication / BadNotSupported
distinctions pass through unmodified.

21 tests pinning arity, order, duplicates, empty batch, one-round-trip, each Bad
code, read-time freshness, the anti-clobber invariant, the deadline, and
cancellation-propagates-but-agent-failure-does-not. CannedAgentClient gains a
cancellation-observing CurrentGate (still no timers or sleeps of its own).
Test csproj takes the AbCip/S7 OTOPCUA0001 NoWarn -- this suite calls the
capability directly by design.

329/329 green.

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.MTConnect.Tests/CannedAgentClient.cs

@@ -81,6 +81,14 @@ internal sealed class CannedAgentClient : IMTConnectAgentClient, IDisposable
     /// <summary>When set, <c>/current</c> throws this instead of answering.</summary>
     public Exception? CurrentFailure { get; set; }
 
+    /// <summary>
+    ///     When set, <c>/current</c> does not answer until this source completes — an Agent that
+    ///     accepted the request and then went quiet. The wait is cancellation-observing, so the
+    ///     caller's own deadline is what ends it; the test never sleeps and never races a timer it
+    ///     did not set. Leave <c>null</c> for the ordinary immediate answer.
+    /// </summary>
+    public TaskCompletionSource? CurrentGate { get; set; }
+
     /// <summary>Number of <c>/probe</c> requests issued against this client.</summary>
     public int ProbeCallCount => Volatile.Read(ref _probeCallCount);
 
@@ -110,15 +118,21 @@ internal sealed class CannedAgentClient : IMTConnectAgentClient, IDisposable
     }
 
     /// <inheritdoc/>
-    public Task<MTConnectStreamsResult> CurrentAsync(CancellationToken ct)
+    public async Task<MTConnectStreamsResult> CurrentAsync(CancellationToken ct)
     {
         ObjectDisposedException.ThrowIf(IsDisposed, this);
         ct.ThrowIfCancellationRequested();
         Interlocked.Increment(ref _currentCallCount);
 
-        return CurrentFailure is null
-            ? Task.FromResult(Current)
-            : Task.FromException<MTConnectStreamsResult>(CurrentFailure);
+        // The request was accepted; the answer is withheld until the test releases the gate or the
+        // caller's deadline cancels the token.
+        var gate = CurrentGate;
+        if (gate is not null)
+        {
+            await gate.Task.WaitAsync(ct).ConfigureAwait(false);
+        }
+
+        return CurrentFailure is null ? Current : throw CurrentFailure;
     }
 
     /// <inheritdoc/>