Add XML documentation to ConnectionTracker methods

Added detailed XML comments to private and public methods in ConnectionTracker and ConnectionInfo classes to improve code maintainability and clarify thread safety, resource management, and intended usage. Also refactored ConnectionInfo constructor to use C# primary constructor syntax.

Author: Taiizor

src/Zetian/Internal/ConnectionTracker.cs

@@ -72,6 +72,14 @@ public int GetConnectionCount(IPAddress ipAddress)
             return 0;
         }
 
+        /// <summary>
+        /// Releases a connection associated with the specified IP address and updates the connection count.
+        /// </summary>
+        /// <remarks>Connection removal is deferred and handled by a cleanup timer to avoid race
+        /// conditions when multiple threads interact with connection state. Immediate removal is not performed to
+        /// ensure thread safety and prevent premature deletion of connection information.</remarks>
+        /// <param name="ipAddress">The IP address for which the connection is being released.</param>
+        /// <param name="info">The connection information object that manages the state and count for the specified IP address.</param>
         private void ReleaseConnection(IPAddress ipAddress, ConnectionInfo info)
         {
             try
@@ -96,6 +104,13 @@ private void ReleaseConnection(IPAddress ipAddress, ConnectionInfo info)
             }
         }
 
+        /// <summary>
+        /// Removes expired connection entries from the internal collection.
+        /// </summary>
+        /// <remarks>This method is intended to be used as a callback for timer-based cleanup operations.
+        /// It safely disposes of expired connections and logs any errors encountered during the cleanup process. The
+        /// method is thread-safe and can be invoked concurrently.</remarks>
+        /// <param name="state">An optional state object provided by the timer or scheduling mechanism. This parameter is not used.</param>
         private void CleanupExpired(object? state)
         {
             try
@@ -130,6 +145,12 @@ private void CleanupExpired(object? state)
             }
         }
 
+        /// <summary>
+        /// Releases all resources used by the instance and disposes of managed connections and timers.
+        /// </summary>
+        /// <remarks>Call this method when the instance is no longer needed to free associated resources
+        /// promptly. After calling <see cref="Dispose"/>, the instance should not be used. This method is safe to call
+        /// multiple times; subsequent calls have no effect.</remarks>
         public void Dispose()
         {
             if (_disposed)
@@ -166,21 +187,14 @@ public void Dispose()
         /// <summary>
         /// Per-IP connection tracking information
         /// </summary>
-        internal sealed class ConnectionInfo : IDisposable
+        internal sealed class ConnectionInfo(int maxConnections) : IDisposable
         {
-            private readonly int _maxConnections;
-            private readonly SemaphoreSlim _semaphore;
+            private readonly SemaphoreSlim _semaphore = new(maxConnections, maxConnections);
             private readonly ReaderWriterLockSlim _lock = new();
             private int _activeConnections = 0;
             private DateTime _lastAccess = DateTime.UtcNow;
             private bool _markedForRemoval = false;
 
-            public ConnectionInfo(int maxConnections)
-            {
-                _maxConnections = maxConnections;
-                _semaphore = new SemaphoreSlim(maxConnections, maxConnections);
-            }
-
             public int CurrentCount
             {
                 get
@@ -301,6 +315,11 @@ public bool TryMarkForRemoval()
                 }
             }
 
+            /// <summary>
+            /// Releases all resources used by the current instance.
+            /// </summary>
+            /// <remarks>Call this method when you are finished using the instance to free unmanaged
+            /// resources. After calling Dispose, the instance should not be used.</remarks>
             public void Dispose()
             {
                 _semaphore?.Dispose();