Address PR #4302 review: reuse Clear() from Shutdown() in both pools

Both pool implementations now delegate the connection drain in Shutdown() to the existing Clear() routine instead of duplicating the drain inline.

ChannelDbConnectionPool.Shutdown(): keeps the CompareExchange election, State transition and _idleChannel.Complete() call, then calls Clear() (which bumps _clearGeneration and best-effort drains the idle channel). A final unbounded drain loop is retained as a mop-up because Clear() may short-circuit when another Clear() is concurrently in flight; the final loop is safe because the channel is already completed and no new writes can succeed.

WaitHandleDbConnectionPool.Shutdown(): keeps the trace, idempotent State check, timer disposal and waiter wake-up, then replaces the inline _stackNew / _stackOld drain loops with a single Clear() call. Clear() additionally dooms every entry in _objectList, decrements the ExitFreeConnection metric per drained connection, and runs ReclaimEmancipatedObjects() — strictly more cleanup than the previous inline drain, with no behaviour change for normal Running-state operations.

Per @mdaigle review feedback on #4302.

Author: priyankatiwari08

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/ChannelDbConnectionPool.cs

@@ -282,17 +282,23 @@ public void Shutdown()
             SqlClientEventSource.Log.TryPoolerTraceEvent(
                 "<prov.DbConnectionPool.Shutdown|RES|INFO|CPOOL> {0}", Id);
 
-            // FR-001: transition to ShuttingDown. After this point, ReturnInternalConnection
+            // Transition to ShuttingDown. After this point, ReturnInternalConnection
             // routes returning connections to RemoveConnection.
             State = ShuttingDown;
 
-            // FR-002 + FR-007: complete the channel writer so:
+            // Complete the channel writer so:
             //  - no further idle connections can be enqueued (TryWrite returns false), and
             //  - in-flight / future async waiters on ReadAsync fault with ChannelClosedException.
             _idleChannel.Complete();
 
-            // FR-003: drain remaining buffered idle connections and destroy them. The channel is
-            // unbounded so all already-enqueued items can be drained synchronously.
+            // Reuse Clear() for the drain. Clear bumps _clearGeneration so any active
+            // checked-out connection fails IsLiveConnection on return and is removed, and it
+            // drains the idle channel up to its captured IdleCount.
+            Clear();
+
+            // Clear() may short-circuit if another caller is already draining. Because the
+            // channel is now completed, no new items can be enqueued, so it is safe to do a
+            // final unbounded drain to mop up anything Clear() may have skipped.
             while (_idleChannel.TryRead(out DbConnectionInternal? connection))
             {
                 if (connection is not null)

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/WaitHandleDbConnectionPool.cs

@@ -1555,17 +1555,11 @@ public void Shutdown()
                 }
             }
 
-            // Drain idle stacks and destroy contained connections. Active checked-out
-            // connections are destroyed when they are returned (see DeactivateObject's
-            // State is ShuttingDown branch).
-            while (_stackNew.TryPop(out DbConnectionInternal newObj))
-            {
-                DestroyObject(newObj);
-            }
-            while (_stackOld.TryPop(out DbConnectionInternal oldObj))
-            {
-                DestroyObject(oldObj);
-            }
+            // Reuse Clear() to doom every connection (including active checked-out ones), drain
+            // both idle stacks, and reclaim emancipated objects. Active connections destroy
+            // themselves on return either via the doom flag or via DeactivateObject's
+            // State == ShuttingDown branch.
+            Clear();
         }
 
         // TransactionEnded merely provides the plumbing for DbConnectionInternal to access the transacted pool