feat: support releasing batches in RecordBatchMemoryCounter

Add uncount_batch, uncount_array, and uncount_batch_with_array_overhead
methods to RecordBatchMemoryCounter. The internal BufferIdSet is changed
to a reference-counted BufferIdMap so that a buffer's capacity is
subtracted from memory_usage only when its refcount drops to zero.

The per-type buffer walk is shared between counting and uncounting via
a visit_array_buffers visitor, avoiding code duplication.

Comprehensive test suite covers all acceptance criteria from #26140:
- Count/uncount round trip (batch, array, batch_with_array_overhead)
- Two-slice shared-buffer example from the issue
- View arrays sharing data buffers (StringView slices, BinaryView)
- Dictionaries sharing values across arrays
- All nested types: List, Map, Union, RunEndEncoded, FixedSizeList,
  FixedSizeBinary, deeply nested (List<Struct<Dict>>)
- Slice-sharing for Union and RunEndEncoded
- Null bitmaps, empty arrays, empty batches, NullArray
- Binary/LargeBinary/Utf8/LargeUtf8 offset+data buffer pairs
- String slices sharing offset+data buffers
- ListView and LargeListView
- Boolean arrays (bit-packed)
- >16 distinct buffers with inline-to-hash promotion + removals
- count_batch_with_array_overhead shared across batches
- Double-uncount idempotency (no underflow)
- Randomized 200-op sequence across 10 diverse array types
  (Int32, Int64, String, StringView, Float64, Dictionary, List,
  Boolean, plus slices) verified against a reference model
- record_batch_memory benchmark with count_uncount case, no regression

Closes #26140

Author: Xiaowei Tan

datafusion/common/benches/record_batch_memory.rs

@@ -180,11 +180,44 @@ fn benchmark_shared_slices(c: &mut Criterion) {
     group.finish();
 }
 
+fn benchmark_count_uncount(c: &mut Criterion) {
+    let mut group = c.benchmark_group("record_batch_memory_size/count_uncount");
+
+    // Model the sort/window workload: batches are counted as they arrive and
+    // uncounted when they are dropped. Measure the full cycle.
+    for num_columns in [4, 16, 64] {
+        let batch = make_primitive_batch(8192, num_columns);
+        let slices = (0..32)
+            .map(|index| batch.slice(index * 256, 256))
+            .collect::<Vec<_>>();
+
+        group.bench_with_input(
+            BenchmarkId::from_parameter(num_columns),
+            &slices,
+            |bencher, slices| {
+                bencher.iter(|| {
+                    let mut counter = RecordBatchMemoryCounter::new();
+                    for batch in black_box(slices) {
+                        black_box(counter.count_batch(black_box(batch)));
+                    }
+                    for batch in black_box(slices) {
+                        black_box(counter.uncount_batch(black_box(batch)));
+                    }
+                    assert_eq!(counter.memory_usage(), 0);
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
 criterion_group!(
     benches,
     benchmark_column_count,
     benchmark_row_count,
     benchmark_array_layout,
-    benchmark_shared_slices
+    benchmark_shared_slices,
+    benchmark_count_uncount
 );
 criterion_main!(benches);