[SPARK-59431][CORE] Use ArrayList instead of LinkedList for BytesToBytesMap dataPages

`BytesToBytesMap` tracked its allocated data pages in a `LinkedList<MemoryBlock>`. Every
operation on this field is an append at the end, a full iteration, an operation at the end
(peek/remove last), or an index access -- there are no head or middle insertions/removals.
That access pattern fits `ArrayList` better than `LinkedList`: contiguous storage (better
iteration locality), no per-page `Node` allocation, and O(1) `get(index)` (used in the
destructive `MapIterator` page advance).

Change `dataPages` to an `ArrayList`. The `getLast()` / `removeLast()` calls (in `spill()`
and `reset()`) are `SequencedCollection` methods available on `ArrayList` only since Java 21;
since Spark supports Java 17 they are rewritten to `get(size() - 1)` / `remove(size() - 1)`
(both O(1) for the last element). The `free()` drain, which used `Iterator.remove()` (O(n^2)
on an `ArrayList`), is rewritten to remove from the end in a loop (O(n)), matching `reset()`.

The sibling field `spillWriters` genuinely uses FIFO front removal (`getFirst()` /
`removeFirst()`) and remains a `LinkedList`; only `dataPages` changes.

No user-facing change: identical behavior; thread-safety is unchanged (access is guarded by
the same external `synchronized` blocks).

Generated-by: Claude Opus 4.8
Co-authored-by: Isaac <no-reply@databricks.com>

Author: david-mollitor-db

core/src/main/java/org/apache/spark/unsafe/map/BytesToBytesMap.java

@@ -20,6 +20,7 @@
 import javax.annotation.Nullable;
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.LinkedList;
 
@@ -103,9 +104,9 @@ public interface KeyOperationsFactory {
   private final TaskMemoryManager taskMemoryManager;
 
   /**
-   * A linked list for tracking all allocated data pages so that we can free all of our memory.
+   * A list for tracking all allocated data pages so that we can free all of our memory.
    */
-  private final LinkedList<MemoryBlock> dataPages = new LinkedList<>();
+  private final ArrayList<MemoryBlock> dataPages = new ArrayList<>();
 
   /**
    * The data page that will be used to store keys and values for new hashtable entries. When this
@@ -413,7 +414,7 @@ public synchronized long spill(long numBytes) throws IOException {
 
       long released = 0L;
       while (dataPages.size() > 0) {
-        MemoryBlock block = dataPages.getLast();
+        MemoryBlock block = dataPages.get(dataPages.size() - 1);
         // The currentPage is used, cannot be released
         if (block == currentPage) {
           break;
@@ -435,7 +436,7 @@ public synchronized long spill(long numBytes) throws IOException {
         writer.close();
         spillWriters.add(writer);
 
-        dataPages.removeLast();
+        dataPages.remove(dataPages.size() - 1);
         released += block.size();
         freePage(block);
 
@@ -1030,10 +1031,8 @@ public void free() {
       freeArray(longArray);
       longArray = null;
     }
-    Iterator<MemoryBlock> dataPagesIterator = dataPages.iterator();
-    while (dataPagesIterator.hasNext()) {
-      MemoryBlock dataPage = dataPagesIterator.next();
-      dataPagesIterator.remove();
+    while (!dataPages.isEmpty()) {
+      MemoryBlock dataPage = dataPages.remove(dataPages.size() - 1);
       freePage(dataPage);
     }
     assert(dataPages.isEmpty());
@@ -1115,7 +1114,7 @@ public void reset() {
     freeArray(longArray);
     longArray = null;
     while (dataPages.size() > 0) {
-      MemoryBlock dataPage = dataPages.removeLast();
+      MemoryBlock dataPage = dataPages.remove(dataPages.size() - 1);
       freePage(dataPage);
     }
     allocate(initialCapacity);