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 │
└────────────────────────────────────────┘
```
expressions.need_aggregate &&
        options.to_stage > QueryProcessingStage::WithMergeableState &&
        !query.group_by_with_totals && !query.group_by_with_rollup && !query.group_by_with_cube;
    bool use_grouping_set_key = expressions.use_grouping_set_key;
    if (query.group_by_with_grouping_sets && query.group_by_with_totals)
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "WITH TOTALS and GROUPING SETS are not supported together");
    if (query.group_by_with_grouping_sets && (query.group_by_with_rollup || query.group_by_with_cube))
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "GROUPING SETS are not supported together with ROLLUP and CUBE");
    if (expressions.hasHaving() && query.group_by_with_totals && (query.group_by_with_rollup || query.group_by_with_cube))
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "WITH TOTALS and WITH ROLLUP or CUBE are not supported together in presence of HAVING");
    if (query_info.projection && query_info.projection->desc->type == ProjectionDescription::Type::Aggregate)
    {
        query_info.projection->aggregate_overflow_row = aggregate_overflow_row;
        query_info.projection->aggregate_final = aggregate_final;
    }
    if (options.only_analyze)
    {
        auto read_nothing = std::make_unique<ReadNothingStep>(source_header);
        query_plan.addStep(std::move(read_nothing));
        if (expressions.filter_info)
        {
            auto row_level_security_step = std::make_unique<FilterStep>(
                query_plan.getCurrentDataStream(),
                expressions.filter_info->actions,
                expressions.filter_info->column_name,
                expressions.filter_info->do_remove_column);
            row_level_security_step->setStepDescription("Row-level security filter");
            query_plan.addStep(std::move(row_level_security_step));
        }
        if (expressions.prewhere_info)