Explicitly construct Span<EValue*> from EValue*[] in tests (#16520)

### Summary

GCC exhibits inconsistent behavior where it applies array-to-pointer
decay when calling through function pointers, but not for direct
function calls, even though both should invoke the same conversion to
the parameter type.

Minimal reproduction:

    template <int N>
    struct S { S(int (&)[N]) {} };

    void f(S<3>) {}

    int main() {
        int a[3];
        f(a);       // OK on both GCC and Clang
        (&f)(a);    // OK on Clang, ERROR on GCC
    }

A similar issue is tracked at: [GCC Bugzilla
114812](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114812)

In ExecuTorch, OpFunction is defined as:

    using OpFunction = void (*)(KernelRuntimeContext&, Span<EValue*>);

When tests call `(*func)(context, stack)` where `stack` is an
`EValue*[]` array, GCC decays it to `EValue**` before considering Span's
array constructor `template<size_t N> Span(T (&)[N])`, causing
compilation to fail.

This PR updates call sites to work around this issue by explicitly
constructing the Span. An alternative option would be to convert the C
arrays to std::arrays, which would not be subject to array to pointer
decay.

### Test plan

```
# Using GCC 11.5
./test/run_oss_cpp_tests.sh
```

Co-authored-by: RJ Ascani <[email protected]>

Author: rascani

extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp

@@ -25,6 +25,7 @@ using executorch::runtime::EValue;
 using executorch::runtime::get_op_function_from_registry;
 using executorch::runtime::KernelRuntimeContext;
 using executorch::runtime::registry_has_op_function;
+using executorch::runtime::Span;
 using std::optional;
 
 Tensor& my_op_out(KernelRuntimeContext& ctx, const Tensor& a, Tensor& out) {
@@ -117,7 +118,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxLogicWorks) {
   EValue* stack[1];
   stack[0] = &values[0];
 
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result
   EXPECT_EQ(a.const_data_ptr<int32_t>()[0], 1);
@@ -144,7 +145,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxArrayRef) {
   KernelRuntimeContext context;
   EValue values[2] = {boxed_array_ref, out};
   EValue* stack[2] = {&values[0], &values[1]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   for (int i = 0; i < 5; i++) {
@@ -170,7 +171,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxOptional) {
   KernelRuntimeContext context;
   EValue values[3] = {scalar, scalar_none, out};
   EValue* stack[3] = {&values[0], &values[1], &values[2]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   EXPECT_EQ(stack[2]->toTensor().const_data_ptr<int32_t>()[0], 4);
@@ -197,7 +198,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxOptionalArrayRef) {
   KernelRuntimeContext context;
   EValue values[2] = {boxed_array_ref, out};
   EValue* stack[2] = {&values[0], &values[1]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   for (int i = 0; i < 5; i++) {