Reject non-default dim order in the portable kernels that copy by block - #21865

### Summary

Follow-up to #21865. Two more portable kernels index with
`getLeadingDims` and `getTrailingDims`, which describe a contiguous run
only in the default dim order.

`unfold_copy` carries no dim order check at all. Checked against the
same logical data in two memory formats:

| kernel | contiguous input | channels-last input |
|---|---|---|
| `aten.unfold_copy` | matches | wrong, max abs diff 14.0 |

It reads `self` as a contiguous run and writes `out` as a flat run, so
neither side survives a non-default layout. `unfold` appears in shipped
example models including the Qualcomm llama vision encoder and the
gemma4 speech transform, where a channels-last input is ordinary.

`select_scatter` has the same arithmetic and the same defect, but it is
not reachable from export today. It carries
`tensors_have_same_dim_order(in, src, out)`, which is not sufficient on
its own, because `is_channels_last_dim_order` accepts 4 and 5 dims, so a
rank-5 input and its rank-4 `src` can both be channels-last and pass
together. At rank 4 the `src` is rank 3 and the check does reject.
Reaching the rank-5 case needs a channels-last dim order that
`exir/dim_order_utils.py` refuses to generate, since it raises for any
rank other than 4. So the kernel is protected by a gap in the export
layer rather than by its own checks, and the guard closes that before 5D
channels-last support makes it reachable.

Both get the guard `op_addmm`, `op_bmm` and the kernels in #21865 use:

```cpp
ET_KERNEL_CHECK(ctx, tensor_is_default_dim_order(in), InvalidArgument, out);
```

`unfold_copy` needs it on `out` as well, since `out` is one rank above
`self` and is written as a flat run. Checking the pair with
`tensors_have_same_dim_order` would not work there, for the same rank
reason as above.

### Test plan

A `NonDefaultDimOrderDies` per kernel, plus a second `unfold_copy` case
covering the `out` guard. Reverting the two kernel sources while keeping
the tests fails all three.

The `select_scatter` test has to be rank 5. A rank-4 case is rejected by
the pre-existing same dim order check on current main, so it would pass
without reaching the new guard. It builds its tensors with
`make_with_dimorder`, because `channels_last_like` asserts `sizes.size()
== 4` and cannot express the failing case.

All three tests skip under `is_aten`, since the ATen kernels handle a
non-default dim order and do not throw.

This also registers `op_unfold_copy_test.cpp` in
`kernels/test/CMakeLists.txt`, without which neither the existing tests
in that file nor the new ones run in a CMake build.

…21866)

### Summary

Related to #21828 and #21865 (same underlying assumption in the
optimized kernel library).

`aten.native_layer_norm` returns wrong data on a channels-last input,
off by 3.192 against eager PyTorch where it matches exactly on
contiguous input. Nothing errors.

The portable kernel is fine. It carries this, with the reason written
down:

```cpp
// Only support default dim order for now.
// TODO: Support other dim orders.
ET_KERNEL_CHECK(
    ctx, tensor_is_default_dim_order(input), InvalidArgument, ret_val);
```

The optimized kernel has neither that check nor the matching
`tensors_have_same_dim_order`, and `native_layer_norm.out` is mapped to
`torch::executor::opt_native_layer_norm_out` in `optimized.yaml`. So any
build with `EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON` gets the ungated one.

It needs the guard rather than stride-aware indexing, because it splits
the buffer into `M` rows of `N` contiguous elements:

```cpp
const size_t M = getLeadingDims(input, dim);
const size_t N = getTrailingDims(input, dim) * dim_size;
```

That layout only exists in the default dim order. This copies the two
checks across from the portable kernel so the two agree.

### Test plan

`OpNativeLayerNormTest.NonDefaultDimOrderDies` passes a channels-last
input with `out`, `mean` and `rstd` all channels-last, so the same dim
order check passes and only the default dim order check can reject.
`mean` and `rstd` share the input's rank with the normalized dims set to
1, which the kernel requires before it reaches any dim order check.

The test file is shared by both kernel libraries, so it runs against the
portable kernel too, where it already passes.