feat: hash partitioning satisfies subset (#19304)

## Which issue does this PR close?

- Closes #19269.

## Rationale for this change
See to issue #19269 for deeper rationale.

DF did not have the notion that being partitioned on a superset of the
required partitioning satisfied the condition. Having this logic will
eliminate unnecessary repartitions and in turn other operators like
partial aggregations.

I introduced this behavior with the `repartition_subset_satisfactions`
flag (default false) as there are some cases where repartitioning may
still be wanted when we satisfy partitioning via this subset property.
In particular, if when partitioned via Hash(a) there is data skew but
when partitioned on Hash(a, b) there is better distribution, a user may
want to turn this optimization off.

I also made it the case such that if we satisfy repartitioning via a
subset but the current amount of partitions < target_partitions, then we
will still repartition to maintain and increase parallelism in the
system when possible.

## What changes are included in this PR?

- Modified `satisfy()` logic to check for subsets and return an enum of
type of match: exact, subset, none
- Do in `EnforceDistribution`, where `satisfy()` is called, do not allow
subset logic for partitioned join operators as partitioning on each side
much match exactly, thus need to repartition if subset logic is true
- Created unit and sqllogictests

## Are these changes tested?
- Unit test
- sqllogictest
- tpch correctness

### Benchmarks
I did not see any drastic changes in benches, but the shuffle
eliminations will be great improvements for distributed DF.

<img width="628" height="762" alt="Screenshot 2025-12-12 at 8 28 15 PM"
src="https://github.com/user-attachments/assets/4b42945f-34e0-46c9-a4ce-e7ccdd0c0603"
/>

<img width="490" height="746" alt="Screenshot 2025-12-12 at 8 30 15 PM"
src="https://github.com/user-attachments/assets/846aef1b-8c5d-462d-83e7-7fa1e2a9372e"
/>

## Are there any user-facing changes?

Yes, users will now have the `repartition_subset_satisfications` option
as described in this PR

---------

Co-authored-by: Andrew Lamb <[email protected]>

Author: gene-bordegaray

datafusion/common/src/config.rs

@@ -1000,6 +1000,34 @@ config_namespace! {
         /// ```
         pub repartition_sorts: bool, default = true
 
+        /// Partition count threshold for subset satisfaction optimization.
+        ///
+        /// When the current partition count is >= this threshold, DataFusion will
+        /// skip repartitioning if the required partitioning expression is a subset
+        /// of the current partition expression such as Hash(a) satisfies Hash(a, b).
+        ///
+        /// When the current partition count is < this threshold, DataFusion will
+        /// repartition to increase parallelism even when subset satisfaction applies.
+        ///
+        /// Set to 0 to always repartition (disable subset satisfaction optimization).
+        /// Set to a high value to always use subset satisfaction.
+        ///
+        /// Example (subset_repartition_threshold = 4):
+        /// ```text
+        ///     Hash([a]) satisfies Hash([a, b]) because (Hash([a, b]) is subset of Hash([a])
+        ///
+        ///     If current partitions (3) < threshold (4), repartition:
+        ///     AggregateExec: mode=FinalPartitioned, gby=[a, b], aggr=[SUM(x)]
+        ///       RepartitionExec: partitioning=Hash([a, b], 8), input_partitions=3
+        ///         AggregateExec: mode=Partial, gby=[a, b], aggr=[SUM(x)]
+        ///           DataSourceExec: file_groups={...}, output_partitioning=Hash([a], 3)
+        ///
+        ///     If current partitions (8) >= threshold (4), use subset satisfaction:
+        ///     AggregateExec: mode=SinglePartitioned, gby=[a, b], aggr=[SUM(x)]
+        ///       DataSourceExec: file_groups={...}, output_partitioning=Hash([a], 8)
+        /// ```
+        pub subset_repartition_threshold: usize, default = 4
+
         /// When true, DataFusion will opportunistically remove sorts when the data is already sorted,
         /// (i.e. setting `preserve_order` to true on `RepartitionExec`  and
         /// using `SortPreservingMergeExec`)