## What happened

On a hybrid Intel+NVIDIA laptop with hibernation enabled (`omarchy hibernation setup`), resume-from-hibernate reliably fails and falls back to a fresh cold boot — losing the entire pre-hibernate session every time.

`journalctl -b 0` on the failed-resume boot:

```
PM: hibernation: resume from hibernation
PM: hibernation: Read 9743492 kbytes in 4.74 seconds (2055.58 MB/s)
nvidia 0000:01:00.0: PM: pci_pm_freeze(): nv_pmops_freeze [nvidia] returns -5
PM: hibernation: Failed to load image, recovering.
PM: hibernation: resume failed (-5)
```

## Expected

Hibernating and then powering back on restores the previous session.

## Root cause

Two Omarchy-generated mkinitcpio drop-ins conflict on hybrid Intel+NVIDIA systems:

1. `install/hardware/nvidia.sh` unconditionally writes `/etc/mkinitcpio.conf.d/nvidia.conf`:
   ```sh
   cat > /etc/mkinitcpio.conf.d/nvidia.conf <<'EOF'
   MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)
   EOF
   ```
   with no check for whether NVIDIA is the *only* GPU. This bundles the NVIDIA modules into the initramfs "for early KMS" even on a hybrid laptop where NVIDIA drives no display at all (confirmed via `dmesg`: `nvidia 0000:01:00.0: [drm] No compatible format found` / `Cannot find any crtc or sizes` on every boot — the Intel iGPU owns the only connected output).

   Compare with `/etc/mkinitcpio.conf.d/omarchy_hooks.conf` (packaged, static), which *does* correctly check for this before dropping the `kms` hook:
   ```sh
   # Drop kms only when nvidia_drm is early-loaded and NVIDIA owns every display
   # controller. Hybrid systems keep kms: their iGPU still needs it for early
   # KMS at the LUKS prompt.
   ...
   if (( _omarchy_nvidia_gpu && !_omarchy_other_gpu )); then
   ```
   `nvidia.sh`'s `MODULES+=` doesn't share this same hybrid-awareness.

2. `omarchy-hibernation-setup` appends the `resume` hook at the very end:
   ```sh
   echo "HOOKS+=(resume)" | sudo tee "$MKINITCPIO_CONF" >/dev/null
   ```
   Its own comment shows awareness of ordering risk:
   ```
   # Add resume= kernel parameters so the initramfs resume hook knows where to find the
   # hibernation image. Without these, resume happens late (after GPU drivers load) and fails.
   ```
   but that comment is about the `resume=`/`resume_offset=` kernel cmdline params (which *are* set correctly), not about module *load* timing.

Because the NVIDIA modules are bundled into the initramfs, the `udev` hook (very early — right after `base`) coldplugs the PCI device and the kernel autoloads `nvidia`/`nvidia_drm`/etc. via modalias matching almost immediately at boot — long before the `resume` hook (which is last, and can't run any earlier than `encrypt`, since it needs `/dev/mapper/root` to exist) gets a turn. By the time the kernel later tries to load the saved hibernation image, it must freeze every currently-loaded driver first, including this freshly (and pointlessly) probed NVIDIA instance — its `pci_pm_freeze` callback fails with `-EIO`, aborting the whole restore.

Reordering the `resume` hook doesn't fix this — `resume` genuinely cannot run before `encrypt`, and `encrypt` is itself after `udev`'s coldplug. The only real fix is to not bundle the NVIDIA modules into the initramfs at all on a hybrid system, since they buy nothing there (no display to drive) and NVIDIA loads fine post-boot for PRIME offload the same way it always did.

## Suggested fix

Give `nvidia.sh` the same hybrid-GPU check `omarchy_hooks.conf` already has, and skip writing the `MODULES+=(nvidia ...)` early-KMS drop-in when a non-NVIDIA GPU is also present (i.e. only bundle NVIDIA into the initramfs when it's the *only* GPU).

## Workaround

A local mkinitcpio drop-in that strips the four NVIDIA modules back out of `MODULES` before the initramfs build, verified with a real hibernate/resume cycle:

```sh
# /etc/mkinitcpio.conf.d/zz-local-hibernate-nvidia-resume-fix.conf
_zz_filtered=()
for _zz_m in "${MODULES[@]}"; do
  case "$_zz_m" in
    nvidia|nvidia_modeset|nvidia_uvm|nvidia_drm) continue ;;
  esac
  _zz_filtered+=("$_zz_m")
done
MODULES=("${_zz_filtered[@]}")
unset _zz_filtered _zz_m
```
then `sudo mkinitcpio -P`.

## System details

- Omarchy 4.0.1-1, kernel 7.1.9-arch1-2
- Dell Precision 5550 (hybrid GPU laptop)
- Display: Intel UHD CometLake-H GT2 (`i915`) — only connected output
- Compute: NVIDIA Quadro T2000 Mobile/Max-Q, Turing (`nvidia-open-dkms` 610.57.04) — PRIME render-offload only, drives no display
- LUKS + btrfs root, Limine bootloader, hibernation configured via `omarchy hibernation setup`

Steps to reproduce:
1. On a hybrid Intel+NVIDIA laptop, run `omarchy hibernation setup`.
2. `systemctl hibernate`.
3. Power the machine back on.
4. Observe a fresh cold boot instead of the restored session; confirm via `journalctl -b 0 | grep -i "pm: hibernation"` showing `resume failed (-5)` and `nv_pmops_freeze ... returns -5`.