fix: bind ExecuTorch TRT engine inputs in delegate arg order

## The problem

When a model with more than one input is compiled to a TensorRT engine and
run through ExecuTorch, the inputs can be delivered to the wrong engine slots.
The failure looks like this at runtime:

    input 'timesteps' rank 4 does not match profile rank 1

The model is fine -- the wrong tensor is simply arriving at that slot.

Why it happens: the ExecuTorch TensorRT runtime backend matches inputs to
engine bindings *by position*. Argument `i` handed to `execute()` is fed to
`input_binding_names[i]`. There are no names attached to the incoming tensors
at runtime; the backend just trusts that the i-th tensor belongs to the i-th
binding name.

But those two lists are built by two different stages that never coordinate:

1. `input_binding_names` is recorded during TensorRT conversion, in the order
   the interpreter visits the subgraph placeholders
   (`_TRTInterpreter.placeholder`).
2. The tensors passed to `executorch_call_delegate` at runtime are ordered by
   ExecuTorch's own lowering: its FX fuser sorts the delegate's placeholder
   inputs by top-level graph order, which can be a different permutation.

For a single-input engine there is nothing to reorder, so it always works.
For a multi-input engine whose inputs get laid out differently after lowering,
the two orders disagree and a tensor lands in the wrong binding -- which either
fails loudly (rank/shape mismatch, as above) or, if two inputs happen to share
a shape, silently produces wrong results.

## Alternatives considered

- Match tensors to bindings by name at runtime. Not possible: the ExecuTorch
  delegate ABI hands `execute()` only positional values, with no names. Adding
  names would require changing the serialized blob format and the runtime ABI.

- Match names to placeholders by name at serialization time. Does not work: the
  TensorRT binding names are the original semantic placeholder targets (e.g.
  `timesteps`, `position_ids`) while the lowered ExecuTorch placeholders are
  generic (`arg_0`, `arg_1`, ...). There is no reliable name correspondence.

- Fix the order earlier, during TensorRT conversion/export. Does not stick:
  ExecuTorch performs another lowering/fusion pass afterward that can re-permute
  the placeholders, so any alignment done before that pass is undone.

## The solution

Reorder `input_binding_names` inside the ExecuTorch backend `preprocess()` --
the first point where both the TensorRT binding order and the final delegate
argument order are visible. The permutation is recovered by *node identity*,
not by name: the engine node's first argument lists its input nodes in binding
order, and each of those nodes is a placeholder in the lowered graph whose
position is exactly the runtime argument slot it will occupy. So we sort the
binding names by each input node's placeholder position.

Single-input engines are naturally identity, so models that already worked are
unaffected. The runtime is unchanged, and the per-binding optimization-profile
bounds follow automatically because they are looked up by name at engine init
(`getProfileShape`).

Adds unit tests in `tests/py/dynamo/executorch/test_backend.py`: single-input
identity, node-identity reorder, generic-name multi-input permutation, and a
guard for a binding-count mismatch.

Author: shoumikhin

py/torch_tensorrt/executorch/backend.py

@@ -58,6 +58,17 @@ def _get_engine_nodes_from_edge_program(edge_program: ExportedProgram) -> List[A
     return _get_engine_nodes_in(edge_program.graph_module.graph.nodes)
 
 
+def _get_single_engine_node(edge_program: ExportedProgram) -> Any:
+    """Return the partition's one TRT engine node, or raise if not exactly one."""
+    engine_nodes = _get_engine_nodes_from_edge_program(edge_program)
+    if len(engine_nodes) != 1:
+        raise RuntimeError(
+            "TensorRT ExecuTorch backend expects exactly 1 engine node per "
+            f"partition, found {len(engine_nodes)}."
+        )
+    return engine_nodes[0]
+
+
 def _get_engine_info_from_edge_program(edge_program: ExportedProgram) -> List[Any]:
     """Extract engine info (list of strings/bytes) from the partition's TRT node.
 
@@ -71,13 +82,9 @@ def _get_engine_info_from_edge_program(edge_program: ExportedProgram) -> List[An
     Uses schema name comparison (not object identity) so it works for both
     OpOverload and EdgeOpOverload targets.
     """
-    engine_nodes = _get_engine_nodes_from_edge_program(edge_program)
-    if len(engine_nodes) != 1:
-        raise RuntimeError(
-            "TensorRT ExecuTorch backend expects exactly 1 engine node per "
-            f"partition, found {len(engine_nodes)}."
-        )
-    return _get_engine_info_for_node(edge_program, engine_nodes[0])
+    return _get_engine_info_for_node(
+        edge_program, _get_single_engine_node(edge_program)
+    )
 
 
 def _get_engine_info_for_node(
@@ -198,6 +205,48 @@ def _parse_device_id(value: Any) -> int:
         return 0
 
 
+def _reorder_input_names_for_executorch(
+    edge_program: ExportedProgram, engine_node: Any, input_names: List[str]
+) -> List[str]:
+    """Reorder TRT binding names into executorch_call_delegate argument order.
+
+    The runtime binds positionally (``execute()`` arg ``i`` -> input_binding_names
+    ``[i]``), but ExecuTorch fusion may permute the delegate placeholders relative
+    to the TRT-submodule order that produced ``input_binding_names``. The names
+    can't be matched (TRT names are semantic, lowered placeholders are generic
+    ``arg_N``), so recover the permutation by node identity: the engine node's
+    first arg lists its input nodes in binding order, so sort the names by each
+    node's slot among the graph placeholders (its runtime delegate-arg position).
+
+    Only inputs need this. Outputs are also bound positionally by the runtime,
+    but they are ``getitem(engine_node, idx)`` nodes whose index order is fixed
+    at creation and equals the engine output-binding order, so ExecuTorch fusion
+    (which only re-sorts external placeholder inputs) cannot permute them.
+    """
+    input_nodes = list(engine_node.args[0])
+    if len(input_nodes) != len(input_names):
+        raise ValueError(
+            "TensorRT ExecuTorch backend: engine has "
+            f"{len(input_names)} input binding names but {len(input_nodes)} "
+            "engine input nodes; cannot establish a reliable binding order."
+        )
+    slot = {
+        node: i
+        for i, node in enumerate(
+            n for n in edge_program.graph_module.graph.nodes if n.op == "placeholder"
+        )
+    }
+    missing = [n for n in input_nodes if n not in slot]
+    if missing:
+        raise ValueError(
+            "TensorRT ExecuTorch backend: engine inputs "
+            f"{[n.name for n in missing]} are not delegate runtime placeholders; "
+            "cannot determine their argument position."
+        )
+    order = sorted(range(len(input_nodes)), key=lambda i: slot[input_nodes[i]])
+    return [input_names[i] for i in order]
+
+
 def _get_str(engine_info: List[Any], index: int, default: str = "") -> str:
     if index < 0 or index >= len(engine_info):
         return default
@@ -223,7 +272,8 @@ def preprocess(
         edge_program: ExportedProgram,
         compile_specs: List[CompileSpec],
     ) -> PreprocessResult:
-        engine_info = _get_engine_info_from_edge_program(edge_program)
+        engine_node = _get_single_engine_node(edge_program)
+        engine_info = _get_engine_info_for_node(edge_program, engine_node)
         engine_info = list(engine_info)
         _validate_engine_info(engine_info)
         serialized_engine = engine_info[ENGINE_IDX]
@@ -240,8 +290,10 @@ def preprocess(
             )
         elif not isinstance(serialized_engine, (bytes, bytearray)):
             engine_info[ENGINE_IDX] = bytes(serialized_engine)
-        input_names = _split_binding_names(
-            _get_str(engine_info, INPUT_BINDING_NAMES_IDX)
+        input_names = _reorder_input_names_for_executorch(
+            edge_program,
+            engine_node,
+            _split_binding_names(_get_str(engine_info, INPUT_BINDING_NAMES_IDX)),
         )
         output_names = _split_binding_names(
             _get_str(engine_info, OUTPUT_BINDING_NAMES_IDX)