fix(ab-transport): per-pool diagnostics + per-device open-attempt limit, CIP-level close recycle, CipConnection/pool test gaps (#566, #581)

- Process-wide CipConnection statics (ForwardOpenCount, Forward Close counts, RequestsSent, exchange
  stats, OpenAttempts, OpenAttemptBudget) move to an instance ConnectionDiagnostics owned by each
  DeviceSessionPool (and by a stand-alone CipConnection). The open-attempt budget becomes a disposable
  per-DeviceKey limit (LimitOpenAttempts); the differential harness scopes one to the press under test.
- LibplctagOrphanRelease.ForceRootingForTest is gone: ReleaseIfOrphaned(tag, canReadHandles) overload.
- A connected reply with general 0x01 / extended 0x0107 or 0x0203 (target no longer holds the class-3
  connection, TCP still up) retires the session at once; the next send reopens through the throttle.
- New tests: dispose during RegisterSession, abandoned-open observer (falsified), scheduler-dispose-throws
  guard (DeviceSessionPool.CloseAsync), release-in-background with a shared open in flight, per-device
  limit scoping, CIP-close recycle (request + keep-alive + negative control).

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

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport/DeviceSessionPool.cs

@@ -52,6 +52,9 @@ public sealed class DeviceSessionPool
     /// <summary>Wiring-test hook: the logger this pool currently writes to (final review I2).</summary>
     internal ILogger Logger => _logger;
 
+    /// <summary>Counters and open-attempt limits for this pool's connections (gate and harness diagnostics).</summary>
+    internal ConnectionDiagnostics Diagnostics { get; } = new();
+
     /// <summary>Test hook: keys with a live entry.</summary>
     internal int EntryCount { get { lock (_lock) return _entries.Count; } }
 
@@ -69,7 +72,7 @@ public sealed class DeviceSessionPool
                 if (!_throttles.TryGetValue(key, out var throttle))
                     _throttles[key] = throttle = new ForwardOpenThrottle(options.MinForwardOpenInterval, _time);
                 var predecessor = _closing.GetValueOrDefault(key) ?? Task.CompletedTask;
-                var connection = new CipConnection(key, options, throttle, _time, predecessor);
+                var connection = new CipConnection(key, options, throttle, _time, predecessor, Diagnostics);
                 entry = new Entry(connection, new RequestScheduler(connection, options.AllowPacking), options, predecessor);
                 _entries[key] = entry;
             }
@@ -109,28 +112,36 @@ public sealed class DeviceSessionPool
             }
         }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
 
-        // Outside the lock: scheduler first (fails its waiters, stops sending), then Forward Close +
-        // UnRegisterSession via the connection. The connection is disposed even if the scheduler's
-        // dispose throws: otherwise its keep-alive would hold the press connection open forever.
+        // Outside the lock.
         try
         {
-            try { await entry.Scheduler.DisposeAsync().ConfigureAwait(false); }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Disposing the request scheduler for {Host}:{Port} failed; closing the connection anyway.",
-                    key.Host, key.Port);
-            }
-            try { await entry.Connection.DisposeAsync().ConfigureAwait(false); }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Closing the connection to {Host}:{Port} failed.", key.Host, key.Port);
-            }
+            await CloseAsync(key, entry.Scheduler, entry.Connection, _logger).ConfigureAwait(false);
         }
         finally
         {
             closed.TrySetResult();   // never faults: a successor only needs to know the close is over
         }
     }
+
+    /// <summary>
+    /// Scheduler first (fails its waiters, stops sending), then Forward Close + UnRegisterSession via the
+    /// connection. The connection is disposed even if the scheduler's dispose throws: otherwise its keep-alive
+    /// would hold the press connection open forever. Never throws; each failure is logged.
+    /// </summary>
+    internal static async Task CloseAsync(DeviceKey key, IAsyncDisposable scheduler, IAsyncDisposable connection, ILogger logger)
+    {
+        try { await scheduler.DisposeAsync().ConfigureAwait(false); }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Disposing the request scheduler for {Host}:{Port} failed; closing the connection anyway.",
+                key.Host, key.Port);
+        }
+        try { await connection.DisposeAsync().ConfigureAwait(false); }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Closing the connection to {Host}:{Port} failed.", key.Host, key.Port);
+        }
+    }
 }
 
 /// <summary>A reference on a device's shared connection. Dispose exactly once (further disposes are no-ops).</summary>