fix(perf): support composite (dual-encoder) models in winml perf

[xieofxie]

Problem

winml perf crashed on composite (dual-encoder) models such as SigLIP/CLIP:

winml perf --ep openvino --device cpu -m google/siglip-base-patch16-224 \
  --task zero-shot-image-classification
...
AttributeError: 'WinMLModelForZeroShotImageClassification' object has no attribute 'io_config'

PerfBenchmark assumed every model exposes a single io_config / _session. Composite
models have neither — they orchestrate multiple sub-models (e.g. an image encoder and a
text encoder), each with its own ONNX session. The failure is device-independent: the
(model_type, task) registry routes SigLIP to the composite class regardless of --device.

Fix

Benchmark each sub-model individually — the same way --module benchmarks each
submodule — instead of timing the aggregate forward() pass:

• run() returns a single BenchmarkResult for single-session models, or a
  {sub_model_name: BenchmarkResult} mapping for composites.
• _run_sub_models() iterates sub_models and benchmarks each through the standard
  single-session pipeline by spawning a child PerfBenchmark with the already-loaded
  sub-model. Every sub-model reuses the existing compile / input-generation / simple +
  monitored loops / result-collection code, so per-sub-model measurement semantics match
  single-model runs exactly (pure-ORT time inside session.perf()).
• Each sub-model reports its own I/O, task, device, and EP — no aggregation.
• report_composite_results() renders a per-sub-model summary table and writes one
  combined JSON nesting each sub-model's full BenchmarkResult.to_dict() under
  components (model_id, task, component_count, components).

This removes the previous aggregate machinery (_aggregate_io_config,
_describe_outputs, _probe_composite_outputs, _composite_run_iteration) and the
composite branches inside the benchmark loops.

_is_composite stays duck-typed on sub_models (rather than
isinstance(..., WinMLCompositeModel)) on purpose: an isinstance check needs a runtime
import of composite_model, which imports torch and would blow the winml perf --help
import budget (tests/cli/test_import_time.py). Keeping WinMLCompositeModel a
TYPE_CHECKING-only import also lets the unit tests use lightweight duck-typed fakes.

Result

Sub-model: image-encoder

Device:      cpu / OpenVINOExecutionProvider
Task:        image-feature-extraction
Inputs:      pixel_values         [1, 3, 224, 224]       float32
Outputs:     last_hidden_state    [1, 196, 768]
             pooler_output        [1, 768]


Sub-model: text-encoder

Device:      cpu / OpenVINOExecutionProvider
Task:        feature-extraction
Inputs:      input_ids            [1, 64]                int32
Outputs:     last_hidden_state    [1, 64, 768]
             pooler_output        [1, 768]


                                                    Per-Sub-Model Perf
┏━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓
┃ Sub-Model     ┃ Task                     ┃ Device                          ┃ Mean (ms) ┃ P90 (ms) ┃ Min (ms) ┃ Max (ms) ┃
┡━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩
│ image-encoder │ image-feature-extraction │ cpu / OpenVINOExecutionProvider │     81.14 │   104.97 │    63.49 │   124.89 │
│ text-encoder  │ feature-extraction       │ cpu / OpenVINOExecutionProvider │     39.19 │    51.89 │    24.99 │   109.08 │
└───────────────┴──────────────────────────┴─────────────────────────────────┴───────────┴──────────┴──────────┴──────────┘

Tests

tests/unit/commands/test_perf_composite.py is rewritten for the per-sub-model behavior:
each sub-model produces its own BenchmarkResult with its own I/O / task / device / EP,
every sub-session is compiled and run warmup + iterations times, and
report_composite_results emits the combined per-component JSON (and JSON-mode stdout).
Existing test_perf_cli.py and test_perf_optracing_cli.py still pass — no regression.

🤖 Generated with Claude Code

[DingmaomaoBJTU]

Overall this PR is well-structured and the approach of duck-typing on sub_models (to avoid torch import at load time) is a reasonable trade-off with a clear explanation. A few issues worth addressing before merge.

[DingmaomaoBJTU]

Follow-up review: 4 of 5 previous findings are fully resolved. One remaining concern on error isolation (see inline comments), and one new minor issue introduced via the merge.

[DingmaomaoBJTU]

New info-level issue (not inlineable — modified line from merge context): perf.py:719 — _resolution variable is named with an underscore prefix, signalling ''intentionally unused'', yet occupies a named binding. Use plain _ as the fourth discard: parent_loader_cfg, _, _, _ = resolve_loader_config(...). If the TaskResolution value is needed later, rename it at that point without the leading underscore.

[DingmaomaoBJTU]

4/5 previous findings are fully resolved. The two remaining items are non-blocking:

• perf.py:374 (warning, partial): \logger.error\ now names the failing sub-model, which is good. The bare
  aise\ still surfaces the original exception without sub-model context at the CLI, but this is a UX improvement rather than a correctness issue — the log output is sufficient for diagnosis.
• perf.py:719 (info): _resolution\ could be plain _\ since it's unused, but this is cosmetic.

Core logic is correct: sub-models are benchmarked independently, results are keyed per component, the duck-type check is properly tightened, the --op-tracing\ gap is closed, and the test coverage is solid. Approving.