fix(Postgres): validate-on-checkout, mirror MsSql pool behaviour

The 1.9.49 retry-on-bad-conn was insufficient: after a postgres
restart the pool typically holds many dead connections, so the first
op fails (caught), AcquireAsync hands out ANOTHER dead one for the
retry, and that second op also fails. Result: every request still
errors with 'terminating connection due to administrator command',
and the only fix is to restart the consuming process.

Verified against a live restart on a production VPS — all six
post-restart probes returned HTTP 500.

Add validate-on-checkout, matching the MsSqlConnectionPool design:
AcquireAsync now loops over idle connections, runs a quick SELECT 1
liveness probe, discards any that fail, and only returns a connection
that successfully responded. If the pool is empty after discards, a
fresh connection is opened. PostgresConnection.IsOpen alone is not
sufficient — it stays true even after the backend kills the socket.

Combined with the WithRetryAsync wrapper from 1.9.49, the pool now
self-heals after a backend restart with zero caller intervention.

Bump version to 1.9.51.

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>1.9.50</Version>
+    <Version>1.9.51</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.Postgres/PostgresConnectionPool.cs

@@ -11,10 +11,14 @@ public sealed class PostgresConnectionPool : ISqlDatabase, IDisposable, IAsyncDi
     private readonly PostgresConfiguration _config;
     private readonly int _maxConnections;
     private readonly Channel<PostgresConnection> _idle;
+    private readonly Func<PostgresConnection, CancellationToken, ValueTask<bool>> _validateConnection;
     private int _count;
     private bool _disposed;
 
-    public PostgresConnectionPool(PostgresConfiguration config, int maxConnections = 10)
+    public PostgresConnectionPool(
+        PostgresConfiguration config,
+        int maxConnections = 10,
+        Func<PostgresConnection, CancellationToken, ValueTask<bool>>? validateConnection = null)
     {
         _config = config;
         _maxConnections = maxConnections;
@@ -24,35 +28,63 @@ public PostgresConnectionPool(PostgresConfiguration config, int maxConnections =
             SingleReader = false,
             SingleWriter = false,
         });
+        _validateConnection = validateConnection ?? DefaultValidateConnectionAsync;
     }
 
     public bool IsOpen => !_disposed;
 
+    private static async ValueTask<bool> DefaultValidateConnectionAsync(PostgresConnection conn, CancellationToken ct)
+    {
+        if (!conn.IsOpen) return false;
+        try
+        {
+            await conn.QueryAsync("SELECT 1", ct: ct).ConfigureAwait(false);
+            return true;
+        }
+        catch (OperationCanceledException) { throw; }
+        catch { return false; }
+    }
+
     // ── Pool acquire/release ───────────────────────────────────────────────────
 
     public async Task<PostgresConnection> AcquireAsync(CancellationToken ct = default)
     {
-        if (_idle.Reader.TryRead(out var conn))
-            return conn;
-
-        int current = Interlocked.Increment(ref _count);
-        if (current <= _maxConnections)
+        while (true)
         {
-            try
+            if (_idle.Reader.TryRead(out var idleConn))
             {
-                var newConn = new PostgresConnection(_config);
-                await newConn.OpenAsync(ct).ConfigureAwait(false);
-                return newConn;
+                if (await _validateConnection(idleConn, ct).ConfigureAwait(false))
+                    return idleConn;
+
+                try { await idleConn.DisposeAsync().ConfigureAwait(false); } catch { }
+                Interlocked.Decrement(ref _count);
+                continue;
             }
-            catch
+
+            int current = Interlocked.Increment(ref _count);
+            if (current <= _maxConnections)
             {
-                Interlocked.Decrement(ref _count);
-                throw;
+                try
+                {
+                    var newConn = new PostgresConnection(_config);
+                    await newConn.OpenAsync(ct).ConfigureAwait(false);
+                    return newConn;
+                }
+                catch
+                {
+                    Interlocked.Decrement(ref _count);
+                    throw;
+                }
             }
-        }
 
-        Interlocked.Decrement(ref _count);
-        return await _idle.Reader.ReadAsync(ct).ConfigureAwait(false);
+            Interlocked.Decrement(ref _count);
+            var pooledConn = await _idle.Reader.ReadAsync(ct).ConfigureAwait(false);
+            if (await _validateConnection(pooledConn, ct).ConfigureAwait(false))
+                return pooledConn;
+
+            try { await pooledConn.DisposeAsync().ConfigureAwait(false); } catch { }
+            Interlocked.Decrement(ref _count);
+        }
     }
 
     public async Task ReleaseAsync(PostgresConnection conn)