perf: grow the value stack out of line (#57)

First of a three-PR stack on `next` (`785be0e`), each on top of the
previous one with individual wins that combine nicely:

1. #57 **perf: grow the value stack out of line** (this PR)
2. #58 perf: inline the fused binop and compare helpers
3. #59 perf: reserve each function's operand stack on entry

`Stack::push` now checks `len == capacity` itself and hands the full
case to a `#[cold] #[inline(never)] push_grow`, which keeps the existing
overflow check and growth. After that check `Vec::push` can no longer
reach its own growth path, so the allocator call leaves the instruction
handlers. It was inlined into every handler that pushes, and the call
made those handlers save and restore four pairs of callee-saved
registers on every execution, even though the default config's stacks
are fixed and never grow. `LocalGet32`'s hot path goes from 57 to 37
instructions on aarch64.

No behavior change: fixed stacks still trap at capacity, and dynamic
stacks still grow up to `max_size`.

**iPhone 12 efficiency cores** (A14 Icestorm, `.utility` QoS). XCode 27
PMU template for low-level CPU stats. 16 benchmark rows, 5 launches per
build, interleaved with the other builds of the stack; cycles and
instructions per call, geomean against `next` as of `b45a98a`:

| | cycles | instructions | rows faster |
|---|---:|---:|---:|
| this PR vs `next` | **−4.1 %** | −3.5 % | 16/16 |

**Checks** on this branch: tinywasm's CI matrix run on my local M4 Mac:
`cargo test --workspace` and `cargo test --workspace --examples` with
`--features tinywasm/nightly-tail-calls`, each with and without default
features

Author: matthargett

crates/tinywasm/src/interpreter/stack/value_stack.rs

@@ -46,22 +46,29 @@ impl<T: Copy + Default> Stack<T> {
 
     #[inline(always)]
     pub(crate) fn push(&mut self, value: T) -> Result<(), Trap> {
-        // Check the limit only at capacity to avoid an extra hot-path check. Vec growth may
-        // intentionally overshoot max_size. Revisit when Vec::push_within_capacity is stable.
-        if self.data.len() == self.data.capacity() && (!self.dynamic || self.data.len() >= self.max_size) {
-            return cold!(Err(Trap::ValueStackOverflow));
+        // At capacity, grow (or trap) out of line. After this check `Vec::push` cannot reach its
+        // own growth path, so the allocator call stays out of the instruction handlers.
+        if self.data.len() == self.data.capacity() {
+            return self.push_grow(value);
         }
         self.data.push(value);
         Ok(())
     }
 
     #[inline(always)]
     pub(crate) fn push_copy(&mut self, index: usize) -> Result<(), Trap> {
-        // Keep the same capacity-based limit check as push, including intentional overshoot.
-        if self.data.len() == self.data.capacity() && (!self.dynamic || self.data.len() >= self.max_size) {
-            return cold!(Err(Trap::ValueStackOverflow));
-        }
         let value = self.data[index];
+        self.push(value)
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn push_grow(&mut self, value: T) -> Result<(), Trap> {
+        // Check the limit only at capacity to avoid an extra hot-path check. Vec growth may
+        // intentionally overshoot max_size.
+        if !self.dynamic || self.data.len() >= self.max_size {
+            return Err(Trap::ValueStackOverflow);
+        }
         self.data.push(value);
         Ok(())
     }