fix(core-abstractions): resolve Low code-review findings (Core.Abstractions-004,005,006,007,008)

- Core.Abstractions-004: guard DriverTypeRegistry.Register with a Lock so
  concurrent registrations are atomic.
- Core.Abstractions-005: narrow PollGroupEngine catch blocks to non-fatal
  exceptions, add optional onError callback, tolerate disposed-CTS races.
- Core.Abstractions-006: document the deliberate int-vs-uint asymmetry on
  IHistoryProvider.ReadEventsAsync / IHistorianDataSource.ReadEventsAsync.
- Core.Abstractions-007: pin the gaps with PollGroupEngine + DriverHealth
  contract tests.
- Core.Abstractions-008: correct XML docs on DriverHealth.LastError and
  the optional / required asymmetry on the history-read surfaces.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

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

@@ -118,4 +118,61 @@ public sealed class IHistorianDataSourceContractTests
 
         healthy.ShouldNotBe(unhealthy);
     }
+
+    /// <summary>
+    ///     Core.Abstractions-006: the <c>maxValuesPerNode</c> (raw / processed) and <c>maxEvents</c>
+    ///     parameter types are intentionally asymmetric — raw/processed reads use <c>uint</c>
+    ///     because OPC UA HistoryRead's NumValuesPerNode is unsigned, while event reads use
+    ///     <c>int</c> to allow zero / negative as a "use backend default cap" sentinel
+    ///     (see <c>WonderwareHistorianClient</c> / <c>HistorianDataSource</c> usage). This test
+    ///     pins both shapes so accidental changes are caught.
+    /// </summary>
+    [Theory]
+    [InlineData("ReadRawAsync", "maxValuesPerNode", typeof(uint))]
+    [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);
+    }
+
+    [Theory]
+    [InlineData("ReadRawAsync", "maxValuesPerNode", typeof(uint))]
+    [InlineData("ReadEventsAsync", "maxEvents", typeof(int))]
+    public void HistoryProvider_MaxParameter_TypePinned(string methodName, string parameterName, Type expectedType)
+    {
+        var method = typeof(IHistoryProvider).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);
+    }
+
+    /// <summary>
+    ///     Core.Abstractions-008: <see cref="IHistoryProvider.ReadAtTimeAsync"/> and
+    ///     <see cref="IHistoryProvider.ReadEventsAsync"/> are C# default interface methods
+    ///     (drivers opt in), whereas <see cref="IHistorianDataSource.ReadAtTimeAsync"/> and
+    ///     <see cref="IHistorianDataSource.ReadEventsAsync"/> are required (the server-side
+    ///     historian must implement them). This test pins the asymmetry so an implementer cannot
+    ///     accidentally collapse the two surfaces and so the documented rationale stays load-bearing.
+    /// </summary>
+    [Theory]
+    [InlineData("ReadAtTimeAsync")]
+    [InlineData("ReadEventsAsync")]
+    public void HistoryProvider_OptionalMethods_HaveDefaultImplementation(string methodName)
+    {
+        var providerMethod = typeof(IHistoryProvider).GetMethod(methodName);
+        providerMethod.ShouldNotBeNull();
+        // Default interface methods carry a method body — IsAbstract is false.
+        providerMethod!.IsAbstract.ShouldBeFalse(
+            $"IHistoryProvider.{methodName} must remain a default-impl-throws method so legacy drivers continue to compile.");
+
+        var dataSourceMethod = typeof(IHistorianDataSource).GetMethod(methodName);
+        dataSourceMethod.ShouldNotBeNull();
+        dataSourceMethod!.IsAbstract.ShouldBeTrue(
+            $"IHistorianDataSource.{methodName} must remain required — server-side historians own the full surface.");
+    }
 }