fix: update schema's data type for LogicalPlan::Values after placeholder substitution (apache#18740)

## Which issue does this PR close?

- Closes apache#18102.

## Rationale for this change

This prepare statements below (no type declaration) fails to execute.
```sql
DataFusion CLI v51.0.0
> PREPARE my_plan AS SELECT a, b FROM (VALUES ($1, $2)) AS t(a, b);
0 row(s) fetched.
Elapsed 0.005 seconds.

> EXECUTE my_plan(1, 2);
Arrow error: Invalid argument error: column types must match schema types, expected Null but found Int64 at column index 0
>
```

To make it works, schema's data type should be updated after replacing
parameters.
But calling `recompute_schema` alone does not suffice because we skip
recomputing schema for `LogicalPlan::Values`:

https://github.com/apache/datafusion/blob/97af468f3da63582f4bacef7d0d1fba4313aa7c4/datafusion/expr/src/logical_plan/plan.rs#L635-L638

## What changes are included in this PR?

- Update schema for `LogicalPlan::Values` manually.

## Are these changes tested?

Yes.

## Are there any user-facing changes?

No.

Author: dqkqd

datafusion/expr/src/logical_plan/plan.rs

@@ -1476,13 +1476,29 @@ impl LogicalPlan {
                     Ok(transformed_expr.update_data(|expr| original_name.restore(expr)))
                 }
             })?
-            // always recompute the schema to ensure the changed in the schema's field should be
-            // poplulated to the plan's parent
-            .map_data(|plan| plan.recompute_schema())
+            .map_data(|plan| plan.update_schema_data_type())
         })
         .map(|res| res.data)
     }
 
+    /// Recompute schema fields' data type after replacing params, ensuring fields data type can be
+    /// updated according to the new parameters.
+    ///
+    /// Unlike `recompute_schema()`, this method rebuilds VALUES plans entirely to properly infer
+    /// types types from literal values after placeholder substitution.
+    fn update_schema_data_type(self) -> Result<LogicalPlan> {
+        match self {
+            // Build `LogicalPlan::Values` from the values for type inference.
+            // We can't use `recompute_schema` because it skips recomputing for
+            // `LogicalPlan::Values`.
+            LogicalPlan::Values(Values { values, schema: _ }) => {
+                LogicalPlanBuilder::values(values)?.build()
+            }
+            // other plans can just use `recompute_schema` directly.
+            plan => plan.recompute_schema(),
+        }
+    }
+
     /// Walk the logical plan, find any `Placeholder` tokens, and return a set of their names.
     pub fn get_parameter_names(&self) -> Result<HashSet<String>> {
         let mut param_names = HashSet::new();

datafusion/sqllogictest/test_files/prepare.slt

@@ -361,3 +361,15 @@ SET datafusion.explain.logical_plan_only=false;
 
 statement ok
 DEALLOCATE my_plan
+
+
+statement ok
+PREPARE my_plan AS SELECT a, b FROM (VALUES ($1, $2)) AS t(a, b);
+
+query II
+EXECUTE my_plan(1, 2)
+----
+1 2
+
+statement ok
+DEALLOCATE my_plan