refactor(#655): delete the dead driver-side history capability

HistoryRead is served server-side by IHistorianDataSource; nothing ever dispatched
to a driver's IHistoryProvider. Removes IHistoryProvider, the OpcUaClient history
passthrough, DriverCapability.HistoryRead (+ resilience tier rows and AdminUI row),
HistoryReadStatusException and its node-manager catches, and the tests that only
covered them. Shared result types and HistoryAggregateNotSupportedException stay
(moved to Historian/HistoryReadContracts.cs). A stored ResilienceConfig still
carrying a HistoryRead key parses (diagnostic only; new test).

Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe

src/Core/ZB.MOM.WW.OtOpcUa.Core.Abstractions/Historian/HistoryReadContracts.cs

@@ -0,0 +1,92 @@
+namespace ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+
+// Shared history result contracts used by IHistorianDataSource and the historian gateway.
+// Drivers carry no history capability (Gitea #655): HistoryRead is served server-side.
+
+
+/// <summary>Result of a HistoryRead call.</summary>
+/// <param name="Samples">Returned samples in chronological order.</param>
+/// <param name="ContinuationPoint">Opaque token for the next call when more samples are available; null when complete.</param>
+public sealed record HistoryReadResult(
+    IReadOnlyList<DataValueSnapshot> Samples,
+    byte[]? ContinuationPoint);
+
+/// <summary>Aggregate function for processed history reads. Mirrors OPC UA Part 13 standard aggregates.</summary>
+/// <remarks>
+///     The first five members are the original set every historian backend serves. The remainder (#285) are
+///     the further standard Part 13 aggregates a server-side HistoryRead can forward to a backend that
+///     supports them (a gateway backend maps them to its own aggregate modes). A backend that cannot serve a
+///     member must throw <see cref="HistoryAggregateNotSupportedException"/> — the server maps that to
+///     <c>BadAggregateNotSupported</c> rather than a generic failure. <b>Append only</b>: the numeric values
+///     are not persisted, but every <c>switch</c> over this enum must keep a total default.
+/// </remarks>
+public enum HistoryAggregateType
+{
+    Average,
+    Minimum,
+    Maximum,
+    Total,
+    Count,
+    Interpolative,
+    TimeAverage,
+    Start,
+    End,
+    Delta,
+    Range,
+    MinimumActualTime,
+    MaximumActualTime,
+    StartBound,
+    EndBound,
+    DeltaBounds,
+    DurationGood,
+    DurationBad,
+    PercentGood,
+    PercentBad,
+    WorstQuality,
+    NumberOfTransitions,
+    AnnotationCount,
+    StandardDeviationPopulation,
+    VariancePopulation,
+}
+
+/// <summary>
+///     Thrown by a history backend when it cannot serve the requested <see cref="HistoryAggregateType"/>.
+///     The Server HistoryRead path translates it to <c>BadAggregateNotSupported</c> for that node only.
+/// </summary>
+public sealed class HistoryAggregateNotSupportedException : NotSupportedException
+{
+    /// <summary>The aggregate the backend could not serve.</summary>
+    public HistoryAggregateType Aggregate { get; }
+
+    /// <summary>Creates the exception for <paramref name="aggregate"/>.</summary>
+    /// <param name="aggregate">The unsupported aggregate.</param>
+    public HistoryAggregateNotSupportedException(HistoryAggregateType aggregate)
+        : base($"The historian backend does not support the {aggregate} aggregate.")
+        => Aggregate = aggregate;
+}
+
+/// <summary>
+///     One row returned by <see cref="IHistorianDataSource.ReadEventsAsync"/> — a historical
+///     alarm/event record, not the OPC UA live-event stream. Fields match the minimum set the
+///     Server needs to populate a <c>HistoryEventFieldList</c> for HistoryReadEvents responses.
+/// </summary>
+/// <param name="EventId">Stable unique id for the event — driver-specific format.</param>
+/// <param name="SourceName">Source object that emitted the event. May differ from the <c>sourceName</c> filter the caller passed (fuzzy matches).</param>
+/// <param name="EventTimeUtc">Process-side timestamp — when the event actually occurred.</param>
+/// <param name="ReceivedTimeUtc">Historian-side timestamp — when the historian persisted the row; may lag <paramref name="EventTimeUtc"/> by the historian's buffer flush cadence.</param>
+/// <param name="Message">Human-readable message text.</param>
+/// <param name="Severity">OPC UA severity (1-1000). Backends map their native priority scale onto this range.</param>
+public sealed record HistoricalEvent(
+    string EventId,
+    string? SourceName,
+    DateTime EventTimeUtc,
+    DateTime ReceivedTimeUtc,
+    string? Message,
+    ushort Severity);
+
+/// <summary>Result of a <see cref="IHistorianDataSource.ReadEventsAsync"/> call.</summary>
+/// <param name="Events">Events in chronological order by <c>EventTimeUtc</c>.</param>
+/// <param name="ContinuationPoint">Opaque token for the next call when more events are available; null when complete.</param>
+public sealed record HistoricalEventsResult(
+    IReadOnlyList<HistoricalEvent> Events,
+    byte[]? ContinuationPoint);

src/Core/ZB.MOM.WW.OtOpcUa.Core.Abstractions/Historian/IHistorianDataSource.cs

@@ -5,15 +5,9 @@ namespace ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 ///     and resolved per OPC UA namespace, independent of any driver's lifecycle.
 /// </summary>
 /// <remarks>
-///     Distinct from <see cref="IHistoryProvider"/>:
-///     <list type="bullet">
-///       <item><see cref="IHistoryProvider"/> is a *driver capability* — the server
-///         dispatches to it via the driver instance.</item>
-///       <item><see cref="IHistorianDataSource"/> is a *server registration* — the
-///         server resolves it via namespace and calls it directly, so a single
-///         historian (e.g. Wonderware) can serve many drivers' nodes, and drivers can
-///         restart without dropping history availability.</item>
-///     </list>
+///     This is a *server registration*, not a driver capability: drivers carry no history
+///     surface (Gitea #655). The server calls it directly, so a single historian can serve
+///     many drivers' nodes, and drivers can restart without dropping history availability.
 ///     All values returned use the shared <see cref="DataValueSnapshot"/> /
 ///     <see cref="HistoricalEvent"/> shapes; backend-specific quality / type encodings
 ///     are translated to OPC UA <c>StatusCode</c> uints inside the data source.
@@ -86,9 +80,7 @@ public interface IHistorianDataSource : IDisposable
     ///     equivalent "use default" sentinel.
     ///
     ///     This surface declares <see cref="ReadAtTimeAsync"/> and <see cref="ReadEventsAsync"/>
-    ///     as required members — a server-side historian owns the full read surface, unlike
-    ///     <see cref="IHistoryProvider"/> where the same two methods are optional default-impl
-    ///     methods so legacy drivers can stay raw-only. The asymmetry is intentional.
+    ///     as required members — a server-side historian owns the full read surface.
     /// </remarks>
     /// <param name="sourceName">The source name to filter events, or null to return events from all sources.</param>
     /// <param name="startUtc">The start of the time range in UTC.</param>