Skip map_expressions rebuild for Extension nodes with empty expressions (apache#21701)

## Which issue does this PR close?

- Closes apache#21700.

## Rationale for this change

When an Extension node has no expressions, `map_expressions` was still
cloning all inputs and calling `with_exprs_and_inputs` to reconstruct
the node — wasted work since there are no expressions to transform. This
is common for Extension nodes like view matching candidates that carry
multiple children but no expressions.

## What changes are included in this PR?

1. **Code change** (`datafusion/expr/src/logical_plan/tree_node.rs`):
Add early return when `node.expressions()` is empty, skipping the clone
+ rebuild path.

2. **Micro-benchmark** (`datafusion/expr/benches/map_expressions.rs`):
Criterion benchmark comparing `map_expressions` on Extension nodes with
and without expressions, varying the number of children (1, 3, 5, 10).

## Are these changes tested?

Yes — existing tests pass, and the new benchmark validates the
optimization.

Benchmark results:

| Children | no_expr (optimized) | with_expr (rebuild) | Speedup |
|----------|--------------------|--------------------|---------|
| 1        | 24 ns              | 167 ns             | 7x      |
| 3        | 23 ns              | 192 ns             | 8x      |
| 5        | 23 ns              | 181 ns             | 8x      |
| 10       | 24 ns              | 216 ns             | 9x      |

The `no_expr` path is constant time regardless of children count.

In a real optimizer pipeline (~15 rules × 5-child Extension), this saves
~2.4 us per optimization pass.

## Next step

A more general optimization would be to change
`UserDefinedLogicalNode::expressions()` to return references (`&[Expr]`)
instead of cloned `Vec<Expr>`, and only clone + rebuild when the
transform actually modifies an expression. This would avoid the clone +
`with_exprs_and_inputs` rebuild even for non-empty expression lists when
the transform is a no-op. Added a TODO comment in the code for this
direction. This would be a larger API change, so the empty-expressions
shortcut is a pragmatic first step.

## Are there any user-facing changes?

No — purely internal optimization. No API changes.

Author: zhuqi-lucas

Cargo.lock

@@ -584,17 +584,29 @@ impl LogicalPlan {
                 .map_elements(f)?
                 .update_data(|expr| LogicalPlan::Sort(Sort { expr, input, fetch })),
             LogicalPlan::Extension(Extension { node }) => {
-                // would be nice to avoid this copy -- maybe can
-                // update extension to just observer Exprs
-                let exprs = node.expressions().map_elements(f)?;
-                let plan = LogicalPlan::Extension(Extension {
-                    node: UserDefinedLogicalNode::with_exprs_and_inputs(
-                        node.as_ref(),
-                        exprs.data,
-                        node.inputs().into_iter().cloned().collect::<Vec<_>>(),
-                    )?,
-                });
-                Transformed::new(plan, exprs.transformed, exprs.tnr)
+                let raw_exprs = node.expressions();
+                if raw_exprs.is_empty() {
+                    // No expressions to transform — skip expensive clone of
+                    // all inputs and reconstruction via with_exprs_and_inputs.
+                    Transformed::no(LogicalPlan::Extension(Extension { node }))
+                } else {
+                    // TODO: a more general optimization would be to change
+                    // `UserDefinedLogicalNode::expressions()` to return
+                    // references (`&[Expr]`) instead of cloned `Vec<Expr>`,
+                    // and only clone + rebuild when the transform actually
+                    // modifies an expression. This would avoid the clone +
+                    // `with_exprs_and_inputs` rebuild even for non-empty
+                    // expression lists when the transform is a no-op.
+                    let exprs = raw_exprs.map_elements(f)?;
+                    let plan = LogicalPlan::Extension(Extension {
+                        node: UserDefinedLogicalNode::with_exprs_and_inputs(
+                            node.as_ref(),
+                            exprs.data,
+                            node.inputs().into_iter().cloned().collect::<Vec<_>>(),
+                        )?,
+                    });
+                    Transformed::new(plan, exprs.transformed, exprs.tnr)
+                }
             }
             LogicalPlan::TableScan(TableScan {
                 table_name,