refactor(core): Optimize and clarify _pdqSiftDown in heapsort

This commit refactors the _pdqSiftDown helper function, which is used as part of the heapsort fallback mechanism within the quickSort implementation.
The changes improve both performance and readability:
1- Key Caching: The key of the current largest element is now cached in a local variable (largestKey). This avoids multiple redundant calls to the keyOf function within the loop, reducing overhead.
2- Clearer Logic: The comparison logic has been restructured. Instead of potentially re-evaluating keyOf(elements[start + largest]) after the first comparison, the cached key is used, and the flow for comparing the root with its left and right children is now more explicit and easier to follow.
3- Early Exit: An early break is introduced for leaf nodes (when left >= n), which slightly simplifies the control flow.
These changes do not alter the algorithm's behavior but make the implementation more efficient and maintainable.

Author: abbashosseinii

pkgs/collection/lib/src/algorithms.dart

@@ -578,24 +578,31 @@ void _pdqSiftDown<E, K>(List<E> elements, K Function(E) keyOf,
   var root = i;
   while (true) {
     final left = 2 * root + 1;
-    final right = 2 * root + 2;
-    var largest = root;
+    if (left >= n) break; // Root is a leaf.
 
-    if (left < n &&
-        compare(keyOf(elements[start + largest]),
-                keyOf(elements[start + left])) <
-            0) {
-      largest = left;
-    }
-    if (right < n &&
-        compare(keyOf(elements[start + largest]),
-                keyOf(elements[start + right])) <
-            0) {
-      largest = right;
+    var largest = root;
+    var largestKey = keyOf(elements[start + largest]);
+
+    // Compare with left child.
+    var child = left;
+    var childKey = keyOf(elements[start + child]);
+    if (compare(largestKey, childKey) < 0) {
+      largest = child;
+      largestKey = childKey;
     }
-    if (largest == root) {
-      break;
+
+    // Compare with right child if it exists.
+    child = left + 1;
+    if (child < n) {
+      childKey = keyOf(elements[start + child]);
+      if (compare(largestKey, childKey) < 0) {
+        largest = child;
+        largestKey = childKey;
+      }
     }
+
+    if (largest == root) break;
+
     _pdqSwap(elements, start + root, start + largest);
     root = largest;
   }