[7.1] 7.1.0 regression: in-flight OpenAsync fails instantly with pool "Timeout expired" when ClearAllPools()/ClearPool() runs #4737

if (State is not Running)
{
    ...
    Interlocked.Decrement(ref _waitCount);
    connection = null;
    return false;
}

timeout = !TryGetConnection(next.Owner, delay, allowCreate: true, onlyOneCheckConnection: false, next.Timeout, out connection);
...
else if (timeout)
{
    next.Completion.TrySetException(ADP.ExceptionWithStackTrace(ADP.PooledOpenTimeout()));
}

using System.Collections.Concurrent;
using System.Diagnostics;
using Microsoft.Data.SqlClient;

// Repro: an async Open that is in flight on a pool when ANY SqlConnection.ClearAllPools() runs.
// Each "worker" opens and closes a connection on its own pool; a "clearer" calls ClearAllPools(), exactly like
// EF Core's EnsureDeleted(). No pool is ever near Max Pool Size.
var baseCs = Environment.GetEnvironmentVariable("REPRO_CS") ?? throw new InvalidOperationException("set REPRO_CS");
int seconds = int.Parse(args.Length > 0 ? args[0] : "20");
int workers = int.Parse(args.Length > 1 ? args[1] : "16");
bool clear = !(args.Length > 2 && args[2] == "noclear");

var asm = typeof(SqlConnection).Assembly;
Console.WriteLine($"Microsoft.Data.SqlClient {FileVersionInfo.GetVersionInfo(asm.Location).ProductVersion?.Split('+')[0]}  ({workers} workers, {seconds}s, ClearAllPools={(clear ? "on" : "OFF")})");

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(seconds));
long opens = 0, clears = 0;
var errors = new ConcurrentDictionary<string, int>();
var elapsedOfFailures = new ConcurrentBag<long>();

var workerTasks = Enumerable.Range(0, workers).Select(i => Task.Run(async () =>
{
    // One pool per worker, reused: nothing leaks, so a run with clearing OFF is a fair control.
    var cs = new SqlConnectionStringBuilder(baseCs) { ApplicationName = "repro-worker-" + i }.ConnectionString;
    while (!cts.IsCancellationRequested)
    {
        var sw = Stopwatch.StartNew();
        try
        {
            await using var c = new SqlConnection(cs);
            await c.OpenAsync();
            Interlocked.Increment(ref opens);
        }
        catch (Exception e)
        {
            elapsedOfFailures.Add(sw.ElapsedMilliseconds);
            var top = e.StackTrace?.Split('\n').FirstOrDefault()?.Trim() ?? "";
            errors.AddOrUpdate($"{e.GetType().Name}: {e.Message.Split('.')[0]} | top frame: {top}", 1, (_, n) => n + 1);
        }
    }
})).ToArray();

var clearer = Task.Run(async () =>
{
    while (clear && !cts.IsCancellationRequested)
    {
        SqlConnection.ClearAllPools();
        Interlocked.Increment(ref clears);
        await Task.Delay(5);
    }
});

await Task.WhenAll(workerTasks.Append(clearer));
Console.WriteLine($"opens ok={opens}  ClearAllPools calls={clears}  FAILED opens={errors.Values.Sum()}");
foreach (var kv in errors.OrderByDescending(k => k.Value)) Console.WriteLine($"  x{kv.Value}  {kv.Key}");
if (!elapsedOfFailures.IsEmpty)
{
    var ms = elapsedOfFailures.OrderBy(x => x).ToArray();
    Console.WriteLine($"  failed-open latency ms: min={ms[0]} median={ms[ms.Length / 2]} max={ms[^1]}   (Connect Timeout is 30000)");
}