refactor(historian): extract Driver.Historian.Sql.Common from the SQL Server backend (no behaviour change) (1a)

Moves the database-independent logic of the SQL Server historian backend into a new
shared library for the upcoming QuestDB backend (#666): status codes and bits, value/column
mapping, StoredSample + quality clamp, the AtTime and aggregate evaluators, BucketPlan,
LiveWritePreparer and HistoryUpdatePlanner (both with a resolutionTicks parameter, default 1),
tag-name rules, the bootstrap failure cache, health counters, alarm event ids, the event
continuation and severity clamp. The SQL Server backend now calls it; its T-SQL, TVP
builders, connection, bootstrapper and catalog stay.

Tests: StatusCodeOracleTests, ValueWriterPrepareTests, the column half of SampleRowMapperTests
and ProcessedReadTests.Every_enum_member_is_either_served_or_refused move to the new
Sql.Common.Tests under the same names. SqlServer integration tests get mechanical renames
only. Test-name set across the three projects is identical to the baseline (160 tests).

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

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer/SqlServerSchemaBootstrapper.cs

@@ -1,17 +1,17 @@
 using System.Data;
 using System.Reflection;
-using System.Runtime.ExceptionServices;
 using System.Text.RegularExpressions;
 using Microsoft.Data.SqlClient;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer;
 
 /// <summary>
 ///     Lazily applies the embedded, idempotent schema scripts once per instance, under a SQL application lock
 ///     so concurrent nodes/instances serialise. A failure is NOT latched: an <see cref="EnsureAsync"/> after
-///     <see cref="FailureCacheDuration"/> retries. Within that window the last failure is re-thrown without touching
+///     <see cref="BootstrapFailureCache.DefaultDuration"/> retries (<see cref="BootstrapFailureCache"/>). Within that window the last failure is re-thrown without touching
 ///     SQL, so a missing schema (or a SQL outage) does not serialise every write, read and alarm event behind one
 ///     semaphore and one round-trip each.
 ///     With <c>AutoCreateSchema=false</c> it only verifies <c>MAX(Version) &gt;= 1</c>.
@@ -24,17 +24,12 @@ internal sealed partial class SqlServerSchemaBootstrapper
     private const string LockResource = "OtOpcUaHistorianSchema";
     private const int LockTimeoutMs = 30_000;
 
-    /// <summary>How long the last bootstrap failure is re-thrown before SQL is tried again.</summary>
-    public static readonly TimeSpan FailureCacheDuration = TimeSpan.FromSeconds(5);
-
     private readonly SqlHistorianConnection _conn;
     private readonly bool _autoCreate;
     private readonly ILogger _log;
-    private readonly TimeProvider _time;
     private readonly SemaphoreSlim _gate = new(1, 1);
+    private readonly BootstrapFailureCache _failure; // guarded by _gate
     private volatile bool _ready;
-    private ExceptionDispatchInfo? _lastFailure;   // guarded by _gate
-    private DateTimeOffset _retryAfter;            // guarded by _gate
 
     /// <summary>Creates the bootstrapper.</summary>
     /// <param name="conn">Connection helper.</param>
@@ -47,7 +42,7 @@ internal sealed partial class SqlServerSchemaBootstrapper
         _conn = conn;
         _autoCreate = options.AutoCreateSchema;
         _log = log ?? NullLogger.Instance;
-        _time = timeProvider ?? TimeProvider.System;
+        _failure = new BootstrapFailureCache(timeProvider ?? TimeProvider.System, BootstrapFailureCache.DefaultDuration);
     }
 
     /// <summary>Ensures the schema is ready; no-op after the first success.</summary>
@@ -61,23 +56,22 @@ internal sealed partial class SqlServerSchemaBootstrapper
         try
         {
             if (_ready) return;
-            if (_lastFailure is { } cached && _time.GetUtcNow() < _retryAfter) cached.Throw();
+            _failure.ThrowIfCached();
             try
             {
                 await using var conn = await _conn.OpenAsync(ct).ConfigureAwait(false);
                 if (_autoCreate) await ApplyAsync(conn, ct).ConfigureAwait(false);
                 else await VerifyAsync(conn, ct).ConfigureAwait(false);
                 _ready = true;
-                _lastFailure = null;
+                _failure.Clear();
             }
             catch (Exception ex) when (ex is not OperationCanceledException || !ct.IsCancellationRequested)
             {
                 // A caller's own cancellation is not a backend failure and is not cached.
-                _lastFailure = ExceptionDispatchInfo.Capture(ex);
-                _retryAfter = _time.GetUtcNow() + FailureCacheDuration;
+                _failure.Record(ex);
                 _log.LogWarning("Historian schema bootstrap for [{Schema}] failed ({Exception}: {Message}); " +
                     "historian calls fail fast for {Seconds} s before retrying.",
-                    _conn.Schema, ex.GetType().Name, ex.Message, FailureCacheDuration.TotalSeconds);
+                    _conn.Schema, ex.GetType().Name, ex.Message, BootstrapFailureCache.DefaultDuration.TotalSeconds);
                 throw;
             }
         }