2.6.1: OpenSSL handshake fails with QUIC_STATUS_TLS_ERROR when ServerName is an IP literal or not set (regression from #6274) #6288

// msquic 2.6.1 regression (OpenSSL backend): the handshake fails with QUIC_STATUS_TLS_ERROR when the
// client's ServerName is an IP literal, or is not set at all (msquic then falls back to the remote IP).
// With 2.6.0 all four cases below connect and certificate validation is deferred to the app callback.
using System.Net;
using System.Net.Quic;
using System.Net.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;

using var key = RSA.Create(2048);
var request = new CertificateRequest("CN=repro", key, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
var san = new SubjectAlternativeNameBuilder();
san.AddIpAddress(IPAddress.Loopback);
san.AddDnsName("localhost");
request.CertificateExtensions.Add(san.Build());
using X509Certificate2 cert = request.CreateSelfSigned(
    DateTimeOffset.UtcNow.AddDays(-1), DateTimeOffset.UtcNow.AddDays(30));

foreach (string? targetHost in new string?[] { "127.0.0.1", null, "localhost", "wrong.example" })
{
    Console.Write($"TargetHost = {targetHost ?? "(null)"} ... ");
    try
    {
        await using var listener = await QuicListener.ListenAsync(new()
        {
            ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0),
            ApplicationProtocols = [new SslApplicationProtocol("test")],
            ConnectionOptionsCallback = (_, _, _) => ValueTask.FromResult(new QuicServerConnectionOptions
            {
                // Both error codes are required by System.Net.Quic: the app-defined codes sent to the
                // peer when a connection or stream is closed without an explicit code.
                DefaultCloseErrorCode = 0,
                DefaultStreamErrorCode = 0,
                ServerAuthenticationOptions = new()
                {
                    ApplicationProtocols = [new SslApplicationProtocol("test")],
                    ServerCertificateContext = SslStreamCertificateContext.Create(cert, null)
                }
            })
        });

        ValueTask<QuicConnection> accepted = listener.AcceptConnectionAsync();
        bool callbackInvoked = false;
        await using var client = await QuicConnection.ConnectAsync(new()
        {
            RemoteEndPoint = listener.LocalEndPoint,
            DefaultCloseErrorCode = 0,
            DefaultStreamErrorCode = 0,
            ClientAuthenticationOptions = new()
            {
                ApplicationProtocols = [new SslApplicationProtocol("test")],
                TargetHost = targetHost,
                RemoteCertificateValidationCallback = (_, _, _, _) => { callbackInvoked = true; return true; }
            }
        }).AsTask().WaitAsync(TimeSpan.FromSeconds(10));

        await using var server = await accepted.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
        Console.WriteLine($"OK (validation callback invoked: {callbackInvoked})");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"FAILED: {ex.Message}");
    }
}