Performance of ORDER BY on sorting key prefix with braces is 2x slower than without due to inefficient execution plan.
Without braces:
```sql
EXPLAIN PIPELINE
SELECT
    CounterID,
    EventDate
FROM hits_v1
ORDER BY
    CounterID ASC,
    EventDate ASC

┌─explain───────────────────────────┐
│ (Expression)                      │
│ ExpressionTransform               │
│   (Sorting)                       │
│   MergingSortedTransform 19 → 1   │
│     (Expression)                  │
│     ExpressionTransform × 19      │
│       (ReadFromMergeTree)         │
│       MergeTreeInOrder × 19 0 → 1 │
└───────────────────────────────────┘
```
With braces:
```sql
EXPLAIN PIPELINE
SELECT
    CounterID,
    EventDate
FROM hits_v1
ORDER BY (CounterID, EventDate) ASC

┌─explain────────────────────────────────┐
│ (Expression)                           │
│ ExpressionTransform                    │
│   (Sorting)                            │
│   MergingSortedTransform 16 → 1        │
│     MergeSortingTransform × 16         │
│       LimitsCheckingTransform × 16     │
│         PartialSortingTransform × 16   │
│           (Expression)                 │
│           ExpressionTransform × 16     │
│             (ReadFromMergeTree)        │
│             MergeTreeThread × 16 0 → 1 │
└────────────────────────────────────────┘
```
expression_before_aggregation->setStepDescription("Before GROUP BY");
                query_plan.addStep(std::move(expression_before_aggregation));
            }
            
            const bool should_produce_results_in_order_of_bucket_number = true;
            executeMergeAggregatedImpl(
                query_plan,
                query_info.projection->aggregate_overflow_row,
                query_info.projection->aggregate_final,
                false,
                false,
                context_->getSettingsRef(),
                query_info.projection->aggregation_keys,
                query_info.projection->aggregate_descriptions,
                should_produce_results_in_order_of_bucket_number);
        }
    }
}
void InterpreterSelectQuery::setMergeTreeReadTaskCallbackAndClientInfo(MergeTreeReadTaskCallback && callback)
{
    context->getClientInfo().collaborate_with_initiator = true;
    context->setMergeTreeReadTaskCallback(std::move(callback));
}
void InterpreterSelectQuery::setProperClientInfo(size_t replica_num, size_t replica_count)
{
    context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
    context->getClientInfo().count_participating_replicas = replica_count;
    context->getClientInfo().number_of_current_replica = replica_num;
}
bool InterpreterSelectQuery::shouldMoveToPrewhere()