feat(historian): #675 reverse HistoryRead-Events paging + end-only backward reads

- IHistorianDataSource.ReadEventsAsync(..., bool reverse, ...) overload: reverse = Part 11 window (lo, hi]
  newest-first by (time, id) DESC. Default forwards forward reads and throws NotSupportedException for
  reverse (Null); Gateway refuses explicitly (ascending-only stream). Server answers
  BadHistoryOperationUnsupported instead of silently returning the earliest N ascending.
- SqlServer / QuestDB serve reverse natively (ORDER BY time DESC, id DESC + TOP/LIMIT).
- Node manager: reverse event reads page with continuation points; direction stored in the cursor
  (HistoryContinuationState.Reverse) so a resume continues in the cursor's direction; reverse tie clusters
  over-fetched forward and sliced from the newest end (SliceTieCluster(reverse:)); end-only reads with a
  cap page backward from EndTime (mirrors raw).
- Resumed event pages over-fetch by the boundary skip, so every non-final page is a full cap page.
- Tests: node-manager reverse paging (ties, clusters, coarse resolution, overfetch bound, resume
  direction both ways, end-only, unsupported backend); shared EventReadConformance on SqlServer +
  QuestDB; over-the-wire reverse paging; offline Gateway pin of the UTC DateTime.MaxValue bound through
  the published client's proto conversion (in-process gRPC capture) and FILETIME.
- docs/Historian.md event paging section.

tests/Core/ZB.MOM.WW.OtOpcUa.Core.Abstractions.Tests/Historian/IHistorianDataSourceContractTests.cs

@@ -45,9 +45,10 @@ public sealed class IHistorianDataSourceContractTests
     [InlineData("ReadEventsAsync", typeof(Task<HistoricalEventsResult>))]
     public void ReadMethods_ReturnExpectedTaskShape(string methodName, Type expectedReturnType)
     {
-        var method = typeof(IHistorianDataSource).GetMethod(methodName);
-        method.ShouldNotBeNull();
-        method!.ReturnType.ShouldBe(expectedReturnType);
+        // ReadEventsAsync is overloaded (the #675 direction-aware overload) — every overload must keep the shape.
+        var methods = Overloads(methodName);
+        methods.ShouldNotBeEmpty();
+        foreach (var method in methods) method.ReturnType.ShouldBe(expectedReturnType);
     }
 
     /// <summary>Verifies that GetHealthSnapshot is synchronous.</summary>
@@ -146,11 +147,14 @@ public sealed class IHistorianDataSourceContractTests
     [InlineData("ReadEventsAsync", "maxEvents", typeof(int))]
     public void HistoryRead_MaxParameter_TypePinned(string methodName, string parameterName, Type expectedType)
     {
-        var method = typeof(IHistorianDataSource).GetMethod(methodName);
-        method.ShouldNotBeNull();
-        var parameter = method!.GetParameters().FirstOrDefault(p => p.Name == parameterName);
-        parameter.ShouldNotBeNull($"Method {methodName} should expose a '{parameterName}' parameter.");
-        parameter!.ParameterType.ShouldBe(expectedType);
+        var methods = Overloads(methodName);
+        methods.ShouldNotBeEmpty();
+        foreach (var method in methods)
+        {
+            var parameter = method.GetParameters().FirstOrDefault(p => p.Name == parameterName);
+            parameter.ShouldNotBeNull($"Method {methodName} should expose a '{parameterName}' parameter.");
+            parameter!.ParameterType.ShouldBe(expectedType);
+        }
     }
 
     /// <summary>
@@ -163,13 +167,17 @@ public sealed class IHistorianDataSourceContractTests
     [Fact]
     public void ReadEventsAsync_sentinel_and_continuation_contract_types_pinned()
     {
-        var method = typeof(IHistorianDataSource).GetMethod("ReadEventsAsync");
-        method.ShouldNotBeNull();
+        var methods = Overloads("ReadEventsAsync");
+        methods.Count.ShouldBe(2, "the five-argument read plus the #675 direction-aware overload");
+        methods.ShouldContain(m => m.GetParameters().Any(p => p.Name == "reverse" && p.ParameterType == typeof(bool)));
 
-        var maxEventsParam = method!.GetParameters().FirstOrDefault(p => p.Name == "maxEvents");
-        maxEventsParam.ShouldNotBeNull("maxEvents parameter must exist for the sentinel contract");
-        maxEventsParam!.ParameterType.ShouldBe(typeof(int),
-            "maxEvents is int (not uint) so callers can pass <=0 as a 'use backend default cap' sentinel");
+        foreach (var method in methods)
+        {
+            var maxEventsParam = method.GetParameters().FirstOrDefault(p => p.Name == "maxEvents");
+            maxEventsParam.ShouldNotBeNull("maxEvents parameter must exist for the sentinel contract");
+            maxEventsParam!.ParameterType.ShouldBe(typeof(int),
+                "maxEvents is int (not uint) so callers can pass <=0 as a 'use backend default cap' sentinel");
+        }
 
         // HistoricalEventsResult must carry a nullable ContinuationPoint so implementations
         // can signal 'more results exist' (non-null) vs 'all results returned' (null).
@@ -179,4 +187,7 @@ public sealed class IHistorianDataSourceContractTests
         continuationProp!.PropertyType.ShouldBe(typeof(byte[]),
             "ContinuationPoint is byte[]? — null means no more pages, non-null means caller must page");
     }
+
+    private static List<System.Reflection.MethodInfo> Overloads(string name) =>
+        typeof(IHistorianDataSource).GetMethods().Where(m => m.Name == name).ToList();
 }

tests/Core/ZB.MOM.WW.OtOpcUa.Core.Abstractions.Tests/Historian/NullHistorianDataSourceTests.cs

@@ -67,6 +67,20 @@ public sealed class NullHistorianDataSourceTests
         result.ContinuationPoint.ShouldBeNull();
     }
 
+    /// <summary>
+    ///     #675: the direction-aware overload's default — forward is the five-argument read, reverse is refused
+    ///     (the server answers <c>BadHistoryOperationUnsupported</c>).
+    /// </summary>
+    [Fact]
+    public async Task Direction_aware_ReadEventsAsync_forwards_forward_and_refuses_reverse()
+    {
+        IHistorianDataSource source = Source;
+        (await source.ReadEventsAsync(null, DateTime.UtcNow.AddHours(-1), DateTime.UtcNow, 0, reverse: false, Ct))
+            .Events.ShouldBeEmpty();
+        await Should.ThrowAsync<NotSupportedException>(() =>
+            source.ReadEventsAsync(null, DateTime.UtcNow, DateTime.UtcNow.AddHours(-1), 0, reverse: true, Ct));
+    }
+
     /// <summary>GetHealthSnapshot reports a fully-disabled (zeroed, disconnected, no-node) shape.</summary>
     [Fact]
     public void GetHealthSnapshot_is_disabled()