feat: route additional scalar expressions through codegen dispatcher

[andygrove]

Which issue does this PR close?

Part of #4506.

Rationale for this change

Comet has a JVM codegen dispatcher (CometCodegenDispatch / CometScalaUDF.emitJvmCodegenDispatch) that runs a Spark expression's own doGenCode inside the Comet native pipeline. This keeps a query native even when there is no Rust implementation (or the Rust implementation diverges from Spark), while guaranteeing behavior matches Spark exactly across supported Spark versions. When the dispatcher is disabled the operator falls back to Spark cleanly.

This PR uses that mechanism in two ways:

1. Add native (dispatched) support for scalar expressions that previously had no Comet support and forced a fallback to Spark.
2. Implement the dispatcher change from [EPIC] Provide JVM/codegen-dispatch implementations for Incompatible expressions so they never fall back by default #4506: an Incompatible native path no longer forces the whole projection back to Spark. Instead the divergent expression is routed through the codegen dispatcher and evaluated correctly inside Comet, with spark.comet.expr.allowIncompatible=true left purely as a perf knob for users who accept the native-path divergence.

What changes are included in this PR?

New scalar expressions (registered as CometCodegenDispatch serdes in QueryPlanSerde):

• math: hypot, nanvl, bround, conv, log1p, pmod, width_bucket, positive
• string: levenshtein, elt, find_in_set, format_number, format_string, overlay, soundex, locate, unbase64, to_char, to_number
• array: sequence
• map: map_concat

Dispatcher change for Incompatible expressions (#4506):

• QueryPlanSerde now routes an Incompatible expression through the codegen dispatcher (when allowIncompatible=false) before falling back to Spark.
• New CometExpressionSerde.allowIncompatCodegenDispatch hook (default true) lets a serde opt out.
• This generically benefits any dispatchable Incompatible expression. For example from_unixtime now executes natively, and the TimestampNTZ branches of hour / minute / second now stay native.

Docs:

• docs/source/user-guide/latest/expressions.md marks the newly dispatched expressions (and map_concat) as supported.

Scope notes:

• JSON and regexp functions are excluded (separate PRs are open): regexp_replace, split, get_json_object, from_json, to_csv opt out of the generic routing.
• Map-typed outputs are now evaluated correctly by the codegen dispatcher, so map_concat is dispatched and the Incompatible BinaryType key/value case of map_from_entries now executes natively instead of falling back.
• Excluded from the new-expression set: generators, RuntimeReplaceable expressions (rewritten before serde), CodegenFallback expressions (e.g. xpath), higher-order functions, interval/null output types, and folded-at-plan-time expressions (current_*).
• Dropped after testing surfaced real issues: try_to_number (throws instead of returning NULL on invalid input) and encode (lowers to StaticInvoke so the class is never seen).
• Incompatible expressions that are CodegenFallback (timezone conversions, parse_url) are not dispatchable and continue to fall back; they need native fixes rather than dispatch.
• collect_set is an aggregate and uses a different serialization path, so it is out of scope here.
• This may change TPC-DS physical plans only if a flipped expression appears in those queries; the affected expressions (e.g. from_unixtime, NTZ hour/minute/second) do not, so no golden-file changes are expected.

How are these changes tested?

Each expression has a SQL file test under spark/src/test/resources/sql-tests/expressions/ run by CometSqlFileTestSuite. The query mode uses checkSparkAnswerAndOperator, which asserts both answer parity with Spark and that the expression executed natively (a fallback fails the test). This includes map_concat and the now-native BinaryType cases of map_from_entries. New and updated fixtures pass against Spark 3.5, with no new regressions in the suite.