[ExecuTorch][WebGPU] Dynamic resize hook for view_copy

Pull Request resolved: #20579

**Make `view_copy` track the live sequence length under dynamic shapes.**

**Problem:** `view_copy` lowers to a flat DMA buffer copy (`add_buffer_copy`) sized at the build-time max shape. With one dynamic graph serving any seq-len S (prefill S=K, decode S=1), the copy moved the full max-S byte count and the output kept its max dims, so a downstream consumer read a live shape that was too large.

**Solution:** register a tensor resize hook on the input so the copy follows the live input numel (a view preserves numel).

- Before: `copy_nbytes` and the output dims are fixed at the serialized max.
- After: the hook recomputes the live numel from `cur_dims(in)`, scales the single dynamic output dim to preserve numel, sets the output `cur_dims`, and rewrites the Copy dispatch's `copy_nbytes`.

**Implementation:**
- Keep the existing DMA path (`Kind::Copy`); the hook only rewrites `copy_nbytes` via `dispatch_at`, no new kernel.
- Handle the aliased in/out fast path (no copy emitted) by still setting the output `cur_dims` so the resize cascade reaches consumers.
- Mirrors Vulkan's `view_buffer` contiguous fast path; numel-preserving like the other dynamic-shape op hooks.

**Constraints:** inert on a static graph (`cur_dims == dims`), so byte-identical to the prior behavior; fp32-only and numel-preserving invariants unchanged.

Co-authored-with: Claude Code.
ghstack-source-id: 399812833
@exported-using-ghexport

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

Author: JCNTH

backends/webgpu/runtime/ops/view_copy/ViewCopy.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <executorch/backends/webgpu/runtime/WebGPUGraph.h>
+#include <executorch/backends/webgpu/runtime/WebGPUUtils.h>
 #include <executorch/backends/webgpu/runtime/ops/OperatorRegistry.h>
 #include <executorch/backends/webgpu/runtime/ops/view_copy/view_copy.h>
 
@@ -38,11 +39,49 @@ void add_flat_copy(WebGPUGraph& graph, int in_id, int out_id) {
   }
 
   // Aliased in/out already in place; CopyBufferToBuffer rejects src == dst.
-  if (in_tensor.buffer == out_tensor.buffer) {
-    return;
-  }
+  const bool aliased = in_tensor.buffer == out_tensor.buffer;
+  const size_t dispatch_idx = aliased
+      ? 0
+      : graph.add_buffer_copy(
+            in_tensor.buffer, out_tensor.buffer, out_tensor.nbytes);
 
-  graph.add_buffer_copy(in_tensor.buffer, out_tensor.buffer, out_tensor.nbytes);
+  // Dynamic shapes: view preserves numel; copy_nbytes + out dims track live in.
+  std::vector<int64_t> out_max = out_tensor.dims;
+  graph.add_tensor_resize_hook(
+      in_id, [in_id, out_id, out_max, dispatch_idx, aliased](WebGPUGraph& g) {
+        const uint64_t target = utils::numel_of(g.cur_dims(in_id));
+        std::vector<int64_t> od = out_max;
+        const uint64_t maxnumel = utils::numel_of(out_max);
+        if (maxnumel != target) {
+          bool resolved = false;
+          // Assumes one dynamic dim; picks the leftmost numel-divisible.
+          for (size_t d = 0; d < od.size(); d++) {
+            if (out_max[d] <= 0) {
+              continue;
+            }
+            const uint64_t rest = maxnumel / static_cast<uint64_t>(out_max[d]);
+            if (rest != 0 && target % rest == 0) {
+              const uint64_t nd = target / rest;
+              if (nd <= static_cast<uint64_t>(out_max[d])) {
+                od[d] = static_cast<int64_t>(nd);
+                resolved = true;
+                break;
+              }
+            }
+          }
+          // Fail loud: a silent miss would leave od at max while copy_nbytes
+          // shrinks to the live size, desyncing consumers from the real copy.
+          if (!resolved) {
+            throw std::runtime_error(
+                "view_copy(resize): could not resolve live output shape");
+          }
+        }
+        g.set_cur_dims(out_id, od);
+        if (!aliased) {
+          g.dispatch_at(dispatch_idx).copy_nbytes =
+              static_cast<size_t>(target) * sizeof(float);
+        }
+      });
 }
 
 namespace {