fix(executor): unwrap NonNull before checking union type in list items

The executor was checking is_union() on the inner type of list items,
but after unwrapping List[NonNull[Union]], the inner type is still
NonNull[Union], not Union directly. is_union() only returns true for
direct UnionType, so union type resolution was being skipped.

Now we unwrap one more level before checking is_union(), allowing
inline fragments on union types within arrays to resolve correctly.

src/swell/executor.gleam

···
                             value.List(items) -> {
                               // Handle list with nested selections
                               // Get the inner type from the LIST wrapper, unwrapping NonNull if needed
+                              // Field type could be: NonNull[List[NonNull[Union]]] or List[NonNull[Union]] etc.
                               let inner_type = case
                                 schema.inner_type(field_type_def)
                               {
···
                               let results =
                                 list.map(items, fn(item) {
                                   // Check if inner_type is a union and resolve it
-                                  let item_type = case
-                                    schema.is_union(inner_type)
+                                  // Need to unwrap NonNull to check for union since inner_type
+                                  // could be NonNull[Union] after unwrapping List[NonNull[Union]]
+                                  let unwrapped_inner = case schema.inner_type(inner_type) {
+                                    option.Some(t) -> t
+                                    option.None -> inner_type
+                                  }
+                                  let item_type = case schema.is_union(unwrapped_inner)
                                   {
                                     True -> {
                                       // Create context with the item value for type resolution
···
                                         schema.context(option.Some(item))
                                       case
                                         schema.resolve_union_type(
-                                          inner_type,
+                                          unwrapped_inner,
                                           resolve_ctx,
                                         )
                                       {