Add concurrent connection A/B benchmark script

Standalone benchmark that measures serial vs concurrent connection
throughput with 10 threads. Used to verify GIL release performance:

Before (GIL held):  0.99x speedup (fully serialized)
After  (GIL released): 5.74x speedup (parallel I/O)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: saurabh500

benchmarks/bench_concurrent_connect.py

@@ -0,0 +1,115 @@
+"""
+A/B benchmark: measure concurrent connection throughput before and after GIL release.
+
+This script is meant to be run twice — once with the baseline .so (GIL held) and
+once with the new .so (GIL released during connect/disconnect). It prints timing
+results that can be compared.
+"""
+import os
+import sys
+import time
+import threading
+import statistics
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+import mssql_python
+from mssql_python import connect
+
+CONN_STR = os.environ["DB_CONNECTION_STRING"]
+NUM_THREADS = 10
+WARMUP = 3
+SERIAL_ROUNDS = 5
+
+
+def connect_and_close():
+    conn = connect(CONN_STR)
+    conn.close()
+
+
+def benchmark_serial():
+    """Measure serial connect/close time."""
+    times = []
+    for _ in range(SERIAL_ROUNDS):
+        start = time.perf_counter()
+        connect_and_close()
+        times.append(time.perf_counter() - start)
+    return times
+
+
+def benchmark_concurrent(n_threads):
+    """Measure wall-clock time for n_threads concurrent connect/close."""
+    barrier = threading.Barrier(n_threads)
+    thread_times = [None] * n_threads
+    errors = []
+
+    def worker(idx):
+        try:
+            barrier.wait(timeout=30)
+            start = time.perf_counter()
+            connect_and_close()
+            thread_times[idx] = time.perf_counter() - start
+        except Exception as e:
+            errors.append((idx, str(e)))
+
+    threads = [threading.Thread(target=worker, args=(i,), daemon=True) for i in range(n_threads)]
+    wall_start = time.perf_counter()
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join(timeout=120)
+    wall_time = time.perf_counter() - wall_start
+    return wall_time, thread_times, errors
+
+
+def main():
+    mssql_python.pooling(enabled=False)
+
+    # Warm up
+    print(f"Warming up ({WARMUP} rounds)...")
+    for _ in range(WARMUP):
+        connect_and_close()
+
+    # Serial baseline
+    print(f"\n--- Serial Baseline ({SERIAL_ROUNDS} rounds) ---")
+    serial_times = benchmark_serial()
+    serial_median = statistics.median(serial_times)
+    print(f"  Individual: {[f'{t*1000:.1f}ms' for t in serial_times]}")
+    print(f"  Median:     {serial_median*1000:.1f} ms")
+
+    # Concurrent
+    print(f"\n--- Concurrent ({NUM_THREADS} threads) ---")
+    results = []
+    for trial in range(3):
+        wall, thread_times, errors = benchmark_concurrent(NUM_THREADS)
+        if errors:
+            print(f"  Trial {trial+1}: ERRORS {errors}")
+            continue
+        results.append(wall)
+        print(f"  Trial {trial+1}: wall={wall*1000:.1f}ms  "
+              f"per-thread=[{', '.join(f'{t*1000:.0f}' for t in thread_times if t)}]ms")
+
+    if not results:
+        print("All trials failed!")
+        return
+
+    concurrent_median = statistics.median(results)
+    serial_estimate = NUM_THREADS * serial_median
+    speedup = serial_estimate / concurrent_median
+
+    print(f"\n{'='*60}")
+    print(f"RESULTS")
+    print(f"{'='*60}")
+    print(f"  Serial median (1 conn):       {serial_median*1000:.1f} ms")
+    print(f"  Serial estimate ({NUM_THREADS} × serial): {serial_estimate*1000:.1f} ms")
+    print(f"  Concurrent median ({NUM_THREADS} threads): {concurrent_median*1000:.1f} ms")
+    print(f"  Speedup:                      {speedup:.2f}x")
+    print(f"{'='*60}")
+
+    if speedup > 2.0:
+        print(f"  ✅ GIL is released — {speedup:.1f}x parallel speedup")
+    else:
+        print(f"  ❌ GIL appears to be held — only {speedup:.1f}x speedup (expected >2x)")
+
+
+if __name__ == "__main__":
+    main()