[slimtensor] Add SlimTensor class with basic properties and CPU copy operation

**Key components:**

1. **`c10/core/Contiguity.h`** - Contiguity checking utility:
   - `_compute_contiguous<T>()` - computes whether a tensor with given sizes/strides is contiguous in memory (row-major order)

2. **`core/SlimTensor.h`** - Main SlimTensor class with:
   - **Constructors**: Default (undefined tensor) and full constructor with storage, sizes, strides, dtype, and storage_offset
   - **Property accessors**:
     - `sizes()`, `size(dim)` - get tensor dimensions with negative indexing support
     - `strides()`, `stride(dim)` - get tensor strides with negative indexing support
     - `dtype()`, `device()`, `device_type()`, `device_index()`
     - `numel()`, `dim()`, `nbytes()`, `itemsize()`
     - `data_ptr()` - returns pointer to tensor data (adjusted for storage_offset)
     - `storage_offset()`, `storage()`
   - **State queries**: `defined()`, `is_cpu()`, `is_contiguous()`, `is_empty()`
   - **Copy operation**: `copy_(other)` - copies data from another tensor
     - Fast path: uses memcpy for both-contiguous tensors
     - Slow path: element-wise copy respecting strides for non-contiguous tensors
   - **Setters**: `reset()`, `set_storage()`, `set_sizes_and_strides()`

**Curretnt constraints:**
- Only CPU device supported
- Only Float32 dtype tested
- copy_() only supports CPU-to-CPU copy

Those contraints will be further improved in the following diffs

Differential Revision: [D89750150](https://our.internmc.facebook.com/intern/diff/D89750150/)

ghstack-source-id: 331051343
Pull Request resolved: #16385

Author: Gasoonjia

backends/aoti/slim/c10/core/Contiguity.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include <executorch/runtime/core/array_ref.h>
+
+namespace executorch::backends::aoti::slim::c10 {
+
+using ::executorch::runtime::ArrayRef;
+
+/**
+ * Compute whether a tensor with given sizes, strides, and numel is contiguous.
+ *
+ * A tensor is contiguous if its elements are laid out in memory in row-major
+ * order, i.e., the stride of the last dimension is 1, and each preceding
+ * dimension's stride equals the product of all following dimensions' sizes.
+ *
+ * @param sizes The sizes of each dimension
+ * @param strides The strides of each dimension
+ * @param numel The total number of elements
+ * @return true if the tensor is contiguous, false otherwise
+ */
+template <typename T>
+bool _compute_contiguous(ArrayRef<T> sizes, ArrayRef<T> strides, T numel) {
+  if (numel == 0) {
+    return true;
+  }
+
+  T expected_stride = 1;
+  // Iterate from last dimension to first
+  for (int64_t d = static_cast<int64_t>(sizes.size()) - 1; d >= 0; d--) {
+    const auto& size_d = sizes[d];
+    if (size_d == 1) {
+      // Size-1 dimensions don't affect contiguity
+      continue;
+    }
+
+    if (strides[d] != expected_stride) {
+      return false;
+    }
+    expected_stride *= size_d;
+  }
+  return true;
+}
+
+} // namespace executorch::backends::aoti::slim::c10

backends/aoti/slim/c10/core/targets.bzl

@@ -54,11 +54,24 @@ def define_common_targets():
         ],
     )
 
+    # Header-only library for Contiguity
+    runtime.cxx_library(
+        name = "contiguity",
+        headers = [
+            "Contiguity.h",
+        ],
+        visibility = ["@EXECUTORCH_CLIENTS"],
+        exported_deps = [
+            "//executorch/runtime/core:core",
+        ],
+    )
+
     # Combined c10 core library
     runtime.cxx_library(
         name = "core",
         visibility = ["@EXECUTORCH_CLIENTS"],
         exported_deps = [
+            ":contiguity",
             ":device",
             ":device_type",
             ":scalar_type",