feat: Upgrades networking to use io_uring. (#2315)

> [!IMPORTANT]
> **Breaking Changes**
> - DecodePacket and EncodePacket delegates replaced with IClientEncryption interface
> - NetState.Connection (Socket) replaced with internal RingSocket management
> - NetState.RecvPipe and NetState.SendPipe removed (buffers managed internally)

## Summary

Upgrades the networking stack from PollGroup-based I/O to io_uring, significantly improving I/O performance on Linux.
This also adds native client encryption support for encrypted UO clients.

## Major Changes

io_uring Networking Architecture
- Replaced PollGroup with IORingGroup for async socket I/O operations
- Removed Pipe.cs (mirrored ring buffer) and TcpServer.cs in favor of RingSocketManager
- Added NetState.Network.cs - centralized network infrastructure handling accept, recv, send, and disconnect
completions
- Added SocketHelper.cs - platform-specific socket utilities for raw socket handle operations (getpeername,
getsockname)
- Buffer management now handled by RingSocketManager with configurable slab allocation

### Client Encryption Support
- Added full encryption stack in Network/Encryption/:
  - EncryptionConfig.cs - configurable encryption modes (None, Unencrypted, Encrypted, Both)
  - EncryptionManager.cs - encryption detection and initialization for login/game packets
  - LoginEncryption.cs - handles login packet encryption with version-derived keys
  - GameEncryption.cs - handles game server encryption using Twofish
  - TwofishEngine.cs - optimized Twofish block cipher implementation
  - LoginKeys.cs - encryption key table for client versions
  - IClientEncryption.cs - interface for client encryption implementations

### NetState Improvements
- Replaced Socket Connection with RingSocket _socket for managed socket lifecycle
- Changed from GCHandle polling to event-based completion processing
- Disconnect handling now properly waits for pending sends to flush
- Simplified connecting socket management using lazy queue removal

### Configuration
- New settings: network.encryptionMode and network.encryptionDebug
- Encryption mode flags: Unencrypted, Encrypted, or Both

### Dependencies
- Replaced PollGroup NuGet package with IORingGroup
- Linux requires liburing-dev / liburing-devel package

### Test plan

- Verify server starts and accepts connections on Linux with io_uring
- Verify server starts and accepts connections on Windows (fallback to IOCP)
- Test unencrypted client connections (ClassicUO with encryption disabled)
- Test encrypted client connections if available
- Verify graceful disconnect flushes pending data
- Confirm CI builds pass on all target platforms

Projects/Server.Tests/Helpers/PacketTestUtilities.cs

@@ -1,16 +1,94 @@
 using System;
+using System.Collections.Generic;
+using System.Net;
 using System.Net.Sockets;
+using System.Network;
 using Server.Network;
 
-namespace Server.Tests.Network
-{
-    public static class PacketTestUtilities
-    {
-        public static Span<byte> Compile(this Packet p) =>
-            p.Compile(false, out var length).AsSpan(0, length);
+namespace Server.Tests.Network;
 
-        public static NetState CreateTestNetState() => new(
-            new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
-        );
+public static class PacketTestUtilities
+{
+    private static nint _testListener;
+    private static int _testPort;
+    private static readonly List<Socket> _testSocketClients = [];
+
+    public static Span<byte> Compile(this Packet p) => p.Compile(false, out var length).AsSpan(0, length);
+
+    /// <summary>
+    /// Creates a NetState for unit testing.
+    /// Uses a real Socket and RingSocket with actual buffers.
+    /// Must be disposed after use (use 'using' statement).
+    /// </summary>
+    public static NetState CreateTestNetState()
+    {
+        NetState.Slice(); // Process disconnects/disposes
+
+        for (var i = _testSocketClients.Count - 1; i >= 0; i--)
+        {
+            var sock = _testSocketClients[i];
+            if (!sock.Connected)
+            {
+                sock.Dispose();
+                _testSocketClients.RemoveAt(i);
+            }
+        }
+
+        var ring = NetState.Ring;
+
+        // Create a test listener if we don't have one (using the ring for RIO-compatible sockets)
+        if (_testListener == 0)
+        {
+            // Disable rate limiter for tests - we don't want connection attempts to be throttled
+            // NetState.DisableRateLimiter();
+
+            _testListener = ring.CreateListener("127.0.0.1", 0, 128);
+            if (_testListener == -1)
+            {
+                throw new InvalidOperationException("Failed to create test listener");
+            }
+
+            _testPort = SocketHelper.GetLocalEndPoint(_testListener)?.Port ?? 0;
+            if (_testPort == 0)
+            {
+                throw new InvalidOperationException("Failed to get test listener port");
+            }
+        }
+
+        // Queue an accept operation
+        ring.PrepareAccept(_testListener, 0, 0, IORingUserData.EncodeAccept());
+        ring.Submit();
+
+        Core._now = DateTime.UtcNow;
+
+        // Create a client socket and connect to trigger the accept
+        var testSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+        testSocket.Connect(IPAddress.Loopback, _testPort);
+        _testSocketClients.Add(testSocket);
+
+        // Slice until we have a new NetState instance added
+        // AcceptEx is asynchronous, so we may need to wait/retry
+        const int maxRetries = 100;
+        for (var i = 0; i < maxRetries; i++)
+        {
+            NetState.Slice();
+
+            // Get the latest instance connected.
+            foreach (var ns in NetState.Instances)
+            {
+                if (ns.ConnectedOn == Core._now)
+                {
+                    return ns;
+                }
+            }
+
+            // Wait a bit for AcceptEx to complete
+            if (i < maxRetries - 1)
+            {
+                System.Threading.Thread.Sleep(1);
+            }
+        }
+
+        throw new Exception("Failed to slice for test NetState instance after retries");
     }
 }