chore(historian): review cleanups for the raw cap

- GatewayHistorianDataSource.ReadRawWindowAsync keeps the cap + 1 probe budget
  (budgetCap) separate from the client's cap: a strict-ceiling or crowding
  refusal now reports Limit = the server cap that applied and advises setting
  NumValuesPerNode at or below it (it said "lower NumValuesPerNode" with
  Limit = cap + 1 to a client that sent 0).
- Fuzz: the oracle-source over-cap assertion was vacuous (cap 0 never counts);
  it now checks no reverse window reached the forward-only shape. Class docs
  name the post-floor cap set (3 ... 1000) and distinguish NumValuesPerNode
  1 / 2 from the smallest server cap.
- HistoryPaging.IsFullPage doc says it judges the REQUEST cap (page + ties +
  lookahead), which is finite under any limit; AdvertiseMaxReturnDataValues
  swallows any exception (returns false for the caller to log), as its doc
  promised.

Refs #736

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

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/HistoryPaging.cs

@@ -131,8 +131,9 @@ internal static class HistoryPaging
     ///     "the maximum number of values that can be returned by the Server for each Node", 0 = no limit). The cap is
     ///     the most values one HistoryRead-Raw page returns (<c>ServerHistorian:MaxRawValuesPerRead</c>), so a client can
     ///     size its <c>NumValuesPerNode</c> and expect a continuation point past it. Idempotent; a re-sync with a
-    ///     different cap overwrites. Never throws: a missing diagnostics manager or node leaves the SDK default (0) and
-    ///     returns <c>false</c> — HistoryRead itself still enforces the cap.
+    ///     different cap overwrites. Never throws: a missing diagnostics manager or node, or any SDK failure writing the
+    ///     property, leaves the SDK default (0) and returns <c>false</c> for the caller to log — HistoryRead itself still
+    ///     enforces the cap.
     /// </summary>
     /// <param name="server">The running server.</param>
     /// <param name="maxRawValuesPerRead">The cap (&lt;= 0 advertises 0 = no limit).</param>
@@ -151,20 +152,22 @@ internal static class HistoryPaging
                 return true;
             }
         }
-        catch (ServiceResultException)
+        catch (Exception)
         {
-            return false;
+            return false; // advisory only: the caller logs; the cap is enforced by HistoryRead regardless
         }
     }
 
     /// <summary>
-    ///     Decide whether a just-returned page is "full" and therefore MAY be followed by more data —
-    ///     the signal to emit a continuation point. A page is full when the client asked for a finite
-    ///     cap (<paramref name="numValuesPerNode"/> &gt; 0) and the backend returned exactly that many
-    ///     samples. A short page (or an unlimited <c>0</c> request) is terminal.
+    ///     Decide whether a just-returned read is "full" and therefore MAY be followed by more data —
+    ///     the signal to emit a continuation point. A read is full when it was issued with a finite request
+    ///     cap (<paramref name="numValuesPerNode"/> &gt; 0 — the <c>RawPagePlan.RequestCap</c>: page + boundary ties +
+    ///     lookahead, which under a backend limit or the server raw cap is always finite, uncapped client reads included)
+    ///     and the backend returned at least that many samples. A short read is terminal; so is a read issued with a
+    ///     request cap of <c>0</c>, which only happens with no limit at all (one shot of the whole window).
     /// </summary>
-    /// <param name="returnedCount">The number of samples the backend returned for this page.</param>
-    /// <param name="numValuesPerNode">The client's per-page cap; <c>0</c> means "no limit".</param>
+    /// <param name="returnedCount">The number of samples the backend returned for this read.</param>
+    /// <param name="numValuesPerNode">The request cap the read was issued with; <c>0</c> means "no limit".</param>
     /// <returns><c>true</c> when a continuation point should be emitted; otherwise <c>false</c>.</returns>
     public static bool IsFullPage(int returnedCount, uint numValuesPerNode) =>
         numValuesPerNode > 0 && returnedCount >= numValuesPerNode;