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 │
└────────────────────────────────────────┘
```
{
                if (expressions.has_order_by)
                    executeOrder(query_plan, input_order_info_for_order);
                
                
                
                
                if (query.limitLength())
                    executeDistinct(query_plan, false, expressions.selected_columns, false);
                if (expressions.hasLimitBy())
                {
                    executeExpression(query_plan, expressions.before_limit_by, "Before LIMIT BY");
                    executeLimitBy(query_plan);
                }
                if (query.limitLength())
                    executePreLimit(query_plan, true);
            }
        };
        if (intermediate_stage)
        {
            if (expressions.first_stage || expressions.second_stage)
                throw Exception("Query with intermediate stage cannot have any other stages", ErrorCodes::LOGICAL_ERROR);
            preliminary_sort();
            if (expressions.need_aggregate)
                executeMergeAggregated(query_plan, aggregate_overflow_row, aggregate_final, use_grouping_set_key);
        }
        if (from_aggregation_stage)
        {
            if (intermediate_stage || expressions.first_stage || expressions.second_stage)
                throw Exception("Query with after aggregation stage cannot have any other stages", ErrorCodes::LOGICAL_ERROR);