Add static-shape inference engine

Static-shape LLM inference engine (StaticShapeEngine). States are discovered by
name and the KV cache is right-sized per context bucket (each bucket graph is
compiled with its own per-ctx strides, so a max-ctx buffer sliced down corrupts
KV); ctx is parsed from the function name.

Input preparation extends Sukru's shared SyncInputHandler / InputContext (apple#147):
concrete handlers (position ids, causal mask, step, RoPE, PLE, sliding) conform
to SyncInputHandler; InputContext gains a per-graph descriptors map so handlers
size their own buffers. No Static input protocol/context — one input family for
dynamic and static engines. State binding uses bind(into:) (apple#156).

Testing: LanguageModelsTests pass incl. new unit tests (ctx-bucket parsing,
causal mask fill); correct output on gemma4-E2B, qwen2.5-1.5B, qwen3-0.6B static.

Depends on apple#156, apple#147.

Author: Carina Peng

swift/Sources/CoreAILanguageModels/Handlers/InputHandler.swift

@@ -18,6 +18,9 @@ public struct InputContext: Sendable {
     public let batchSize: Int
     /// Sliding window size (nil for models without sliding attention).
     public let slidingWindow: Int?
+    /// The active graph's input descriptors, keyed by input name. Lets a handler size its
+    /// own output buffer to the running bucket. Empty for engines that don't vary by bucket.
+    public let descriptors: [String: NDArrayDescriptor]
 
     /// For dynamic-shape engines (Sequential, Pipelined).
     /// alignedStep = processedTokenCount, batchSize = tokens.count.
@@ -30,22 +33,25 @@ public struct InputContext: Sendable {
             processedTokenCount: processedTokenCount,
             alignedStep: processedTokenCount,
             batchSize: tokens.count,
-            slidingWindow: nil)
+            slidingWindow: nil,
+            descriptors: [:])
     }
 
     /// For static-shape engines. Batch is fixed-size and aligned.
     public static func `static`(
         tokens: ArraySlice<Int32>,
         alignedStep: Int,
         batchSize: Int,
-        slidingWindow: Int?
+        slidingWindow: Int?,
+        descriptors: [String: NDArrayDescriptor] = [:]
     ) -> InputContext {
         InputContext(
             tokens: tokens,
             processedTokenCount: alignedStep,
             alignedStep: alignedStep,
             batchSize: batchSize,
-            slidingWindow: slidingWindow)
+            slidingWindow: slidingWindow,
+            descriptors: descriptors)
     }
 }