refactor: move array expression support checks to getSupportLevel

[andygrove]

Which issue does this PR close?

Part of #4673.

Rationale for this change

The serde framework intends that an expression declares whether it can be accelerated through getSupportLevel, with the central dispatcher in QueryPlanSerde translating Incompatible/Unsupported into the appropriate fallback. Several array serdes instead made these decisions inside convert by calling withFallbackReason directly, even though the decisions are statically determinable from the expression.

What changes are included in this PR?

Move static support decisions out of convert and into getSupportLevel for the array expressions:

• ArrayRemove, Flatten, ArrayPosition: unsupported input data types, via a shared ArraysBase.childTypesSupportLevel helper.
• ArrayPosition: all-foldable arguments fall back so Spark's ConstantFolding can handle them.
• SortArray: ascendingOrder must be a boolean literal (folded into the existing getSupportLevel).
• ElementAt: the input must be an array (Map inputs fall back).

This is behavior-preserving: every case that previously fell back to Spark continues to fall back with the same reason. The remaining withFallbackReason calls in this file are child-reason rollups, which are the intended use inside convert.

ArrayExcept and ArrayReverse are intentionally left for a follow-up. Their isTypeSupported checks interact with the codegen-dispatch routing used for Incompatible expressions (a binary-array reverse, for example, stays native via the codegen dispatcher), so reclassifying those checks as Unsupported would change routing and is not behavior-preserving in isolation.

How are these changes tested?

Covered by existing tests in CometArrayExpressionSuite (41 tests), which exercise both the supported and fallback paths for these expressions.

[comphead]

in Apache Spark, the ElementAt supports Map, and Comet gates for Array only, we should support Map

  override def inputTypes: Seq[AbstractDataType] = {
    (left.dataType, right.dataType) match {
      case (arr: ArrayType, e2: IntegralType) if (e2 != LongType) =>
        Seq(arr, IntegerType)
      case (MapType(keyType, valueType, hasNull), e2) =>
        TypeCoercion.findTightestCommonType(keyType, e2) match {
          case Some(dt) => Seq(MapType(dt, valueType, hasNull), dt)
          case _ => Seq.empty
        }
      case (l, r) => Seq.empty

    }
  }

[comphead]

#4684

[comphead]

Thanks @andygrove