Support hybrid attention architectures in LayerWrapper (#2367)

## Summary

Allow `LayerWrapper` to handle models with hybrid layer types (e.g.,
Qwen3.5) where some decoder layers use linear attention instead of
standard self-attention.

## Problem

Qwen3.5 is a hybrid VL model with 24 decoder layers — 18 use
GatedDeltaNet linear attention (`linear_attn` sub-module) and 6 use
standard full attention (`self_attn`). When Olive's
`SelectiveMixedPrecision` or `GPTQ` passes wrap each layer with
`LayerWrapper`, the constructor calls:

```python
self.attn, self.attn_name = get_submodules(
    layer, self.ATTENTION, self.model_type, return_name=True
)
```
This raises ```ValueError```for GatedDeltaNet layers since they don't
have a ```self_attn``` attribute.

Fix
Pass ```fail_on_not_found=False``` to the attention sub-module lookup in
```LayerWrapper.__init__```:
```
- self.attn, self.attn_name = get_submodules(
-     layer, self.ATTENTION, self.model_type, return_name=True
- )
+ # Use fail_on_not_found=False to support hybrid architectures (e.g., Qwen3.5)
+ # where some layers use linear attention instead of standard self-attention
+ self.attn, self.attn_name = get_submodules(
+     layer, self.ATTENTION, self.model_type, return_name=True, fail_on_not_found=False
+ )
```
When a layer doesn't have a standard attention module, ```self.attn```
is set to None and the calibration passes gracefully skip
attention-specific quantization for that layer while still processing
the MLP.

Author: apsonawane

olive/common/hf/wrapper.py

@@ -134,7 +134,11 @@ def __init__(self, layer: nn.Module, model_type: str):
         self.layer = layer
         self.model_type = model_type
 
-        self.attn, self.attn_name = get_submodules(layer, self.ATTENTION, self.model_type, return_name=True)
+        # Use fail_on_not_found=False to support hybrid architectures (e.g., Qwen3.5)
+        # where some layers use linear attention instead of standard self-attention
+        self.attn, self.attn_name = get_submodules(
+            layer, self.ATTENTION, self.model_type, return_name=True, fail_on_not_found=False
+        )
         self.mlp, self.mlp_name = get_submodules(layer, self.MLP, self.model_type, return_name=True)
 
     def get_first_layer_norm(self, return_name: bool = True):
@@ -144,6 +148,8 @@ def get_second_layer_norm(self, return_name: bool = True):
         return get_submodules(self.layer, self.SECOND_LAYER_NORM, self.model_type, return_name=return_name)
 
     def get_attention_inputs(self, return_name: bool = True):
+        if self.attn is None:
+            return ([], []) if return_name else []
         attention_inputs, names = get_submodules(
             self.attn, self.ATTENTION_INPUTS, self.model_type, return_name=True, return_name_prefix=f"{self.attn_name}."
         )
@@ -153,6 +159,8 @@ def get_attention_inputs(self, return_name: bool = True):
         return attention_inputs if not return_name else (attention_inputs, names)
 
     def get_attention_outputs(self, return_name: bool = True):
+        if self.attn is None:
+            return ([], []) if return_name else []
         return get_submodules(
             self.attn,
             self.ATTENTION_OUTPUTS,
@@ -274,6 +282,8 @@ def maybe_untie_word_embeddings(self):
     def maybe_unpack_qkv(self):
         """Unpack the QKV projection matrix into separate projections for models like phi3."""
         for layer_wrapper in self.get_layer_wrappers():
+            if layer_wrapper.attn is None:
+                continue
             attn_inputs, attn_input_names = layer_wrapper.get_attention_inputs()
 
             if len(attn_inputs) != 1 or not isinstance(attn_inputs[0], nn.Linear):