test(historian): paged-vs-unpaged raw-cap fuzz, MaxReturnDataValues advertisement, cap floor of 3

- NodeManagerHistoryReadRawCapFuzzTests: 10k seeds (env OTOPCUA_PAGING_FUZZ_ITERATIONS)
  through a real SDK node manager against wire-faithful fakes of SqlServer / QuestDB /
  Gateway that enforce the backend half of the cap; random series with ties, random
  windows (empty, on/past a tie, between samples, forward/reverse/end-only, bounds),
  N in {0,1,2,small,huge}, cap in {off,3..1000}, tie budget {3,8,65536}. Pages must
  concatenate to the cap-off one-shot answer (checked against the series), terminate
  within values + 2 (+ one empty step per oversized boundary cluster), never exceed
  the cap, never ask the backend for 0 / over-cap; refusals only past the budget.
- HistoryPaging.AdvertiseMaxReturnDataValues writes HistoryServerCapabilities/
  MaxReturnDataValues (i=11273), read back through the SDK master node manager.
- MinMaxRawValuesPerRead raised to 3: at 2 a resumed page has no room (value + its
  boundary tie + lookahead) and every value cost an empty page + CP (seed 15).
- RawPageLimit rows pin the default-cap arithmetic (9 999 first page, 9 998 resumed).

Fuzz findings recorded as follow-ups: a bounded read whose data fits one page
returns cap + 1 (end bound fitted against N, not the cap; node manager, F2);
the Gateway walk-back's cost on a sparse series under a tiny tie budget is
pre-existing (seed 320: 82 reads uncapped, 93 capped).

Refs #736

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

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Historian/ServerHistorianOptions.cs

@@ -158,10 +158,12 @@ public sealed class ServerHistorianOptions
     public const int DefaultMaxRawValuesPerRead = 10_000;
 
     /// <summary>
-    ///     The smallest usable <see cref="MaxRawValuesPerRead"/>: a read must carry a page of at least one value AND the
-    ///     lookahead row that tells the server more data follows, so a cap of 1 is raised to 2 (<see cref="EffectiveMaxRawValuesPerRead"/>).
+    ///     The smallest usable <see cref="MaxRawValuesPerRead"/>: a resumed page's read must carry at least one value, the
+    ///     boundary tie it re-reads and trims, AND the lookahead row that tells the server more data follows. At 2 a resumed
+    ///     page has no room at all and every value costs an empty page with a continuation point (the #692 defect, re-created
+    ///     by configuration), so 1 and 2 are raised to 3 (<see cref="EffectiveMaxRawValuesPerRead"/>).
     /// </summary>
-    public const int MinMaxRawValuesPerRead = 2;
+    public const int MinMaxRawValuesPerRead = 3;
 
     /// <summary>
     ///     Every backend: the most raw values the server returns on ONE HistoryRead-Raw page, and the most rows one
@@ -175,8 +177,10 @@ public sealed class ServerHistorianOptions
     ///     and is REFUSED (<c>BadTooManyOperations</c>) when the window holds more — never answered truncated — so a caller that
     ///     bypasses the node manager's paging cannot bypass the bound. On the Gateway backend a strict gateway's learned row
     ///     ceiling (less its boundary-row allowance) still applies when lower. The tie-cluster bound of a resumed page is also
-    ///     at most cap − 1 (as under a gateway ceiling; <see cref="MaxTieClusterOverfetch"/> above that is inert). Default
-    ///     10 000. Non-positive = unbounded, the pre-#736 behaviour (a <see cref="Validate"/> warning); 1 is raised to 2.
+    ///     at most cap − 1 (as under a gateway ceiling; <see cref="MaxTieClusterOverfetch"/> above that is inert), and a
+    ///     page whose boundary tie cluster is that large steps past it with one empty page. Default 10 000. Non-positive =
+    ///     unbounded, the pre-#736 behaviour (a <see cref="Validate"/> warning); below <see cref="MinMaxRawValuesPerRead"/>
+    ///     (3) is raised to it.
     /// </summary>
     public int MaxRawValuesPerRead { get; init; } = DefaultMaxRawValuesPerRead;
 
@@ -243,7 +247,7 @@ public sealed class ServerHistorianOptions
         if (MaxRawValuesPerRead <= 0)
             warnings.Add($"ServerHistorian:MaxRawValuesPerRead is {MaxRawValuesPerRead} — must be > 0; HistoryRead-Raw pages and backend raw reads are unbounded, so a client asking for a whole window (NumValuesPerNode = 0) materialises every sample in memory.");
         else if (MaxRawValuesPerRead < MinMaxRawValuesPerRead)
-            warnings.Add($"ServerHistorian:MaxRawValuesPerRead is {MaxRawValuesPerRead} — must be at least {MinMaxRawValuesPerRead} (a page plus its lookahead row); treated as {MinMaxRawValuesPerRead}.");
+            warnings.Add($"ServerHistorian:MaxRawValuesPerRead is {MaxRawValuesPerRead} — must be at least {MinMaxRawValuesPerRead} (a value, its boundary tie and the lookahead row); treated as {MinMaxRawValuesPerRead}.");
         if (EventReadHorizon < TimeSpan.Zero)
             warnings.Add($"ServerHistorian:EventReadHorizon is {EventReadHorizon} — negative is treated as no horizon (00:00:00); HistoryReadEvents reads every window in full.");
         if (HistoryReadDeadline <= TimeSpan.Zero)