feat(dynamo): add target_executorch setting to keep output-allocator ops in PyTorch

[shoumikhin]

Description

Some converters require a TensorRT output allocator because their output shape is
data-dependent (for example aten.nonzero). A TensorRT engine that needs an output
allocator cannot be consumed by every downstream runtime that executes the compiled
program.

This adds a target_executorch compile setting (default False). When enabled, every
operator whose converter sets requires_output_allocator is routed to
torch_executed_ops and runs in PyTorch instead of being lowered into a TensorRT
engine. When disabled (the default), behavior is unchanged.

Details

• Discovery and routing are factored into two small helpers (_output_allocator_ops
  and _route_output_allocator_ops) so both are unit-testable without a GPU. The
  registry walk handles a single converter, a list/tuple, or a priority-keyed dict,
  and is conservative: if any converter for a target needs an allocator, the whole
  target is routed to PyTorch so an allocator engine is never emitted.
• Wired through compile() and cross_compile_for_windows(); the routing runs in
  compile_module(), which both entry points funnel through. It is intentionally not
  exposed on convert_exported_program_to_serialized_trt_engine(), where a single
  serialized engine cannot contain PyTorch fallbacks.
• Combining target_executorch with require_full_compilation raises a clear error,
  since routing ops to PyTorch contradicts full compilation.
• CompilationSettings.__setstate__ defaults the new field so older pickles load.

The name is deliberate: it gates ExecuTorch-targeted routing, and further
ExecuTorch-specific behavior can accrete under the same flag.

Tests

tests/py/dynamo/models/test_target_executorch.py:

• the setting defaults to False and is settable;
• a state missing the field (older pickle) restores to False;
• output-allocator converters are discoverable via requires_output_allocator;
• routing is a no-op when the flag is off;
• routing adds the op to torch_executed_ops when on (CPU only, no GPU needed);
• combining with require_full_compilation raises;
• end to end on GPU, a data-dependent op (nonzero) falls back to PyTorch.

Type of change

• New feature (non-breaking change which adds functionality)

Checklist

• My code follows the style guidelines of this project (isort + black)
• I have added tests that prove my fix/feature works
• Commit is signed off (DCO)