`PluginRegistry` spawns the local-plugin watcher as a Quickshell `Process`, but nothing ties that child to the shell's lifetime. When the shell exits without running destructors, the `inotifywait` survives and is reparented to `systemd --user`. Every such exit strands one more.

They accumulate against `fs.inotify.max_user_instances` (1024 per UID). Once it fills, `inotify_init1()` returns `EMFILE` for the whole user session, and the failure surfaces in whatever application next asks for a watch. In my case that was Alacritty refusing to start with "too many open files" — Alacritty was the messenger, not the cause.

## Why the child outlives the shell

`shell/services/PluginRegistry.qml`:

```qml
property Process localPluginWatcher: Process {
  command: [
    "inotifywait", "-m", "-r", "-q",
    "-e", "close_write,create,delete,move",
    "--format", "%w%f",
    registry.pluginsDir
  ]
  ...
  onExited: localPluginWatcherRestart.restart()
}
```

An in-process cleanup can't cover this, because the relevant exits are exactly the ones that skip destructors. `bin/omarchy-launch-shell` already documents the mode:

> Quickshell relaunches itself from its signal handlers, but Qt leaves through `_exit()` when the Wayland connection fails, raising no signal: no crash report, no relaunch, no bar.

A deliberate `omarchy-restart-shell` does stop the watcher cleanly — I measured an unpatched shell across a restart and it left no orphan — so this is the crash path specifically, where no destructor runs.

## Reproduction

Three lines of QML, no Omarchy needed:

```qml
// /tmp/leaktest/shell.qml
import Quickshell
import Quickshell.Io
ShellRoot {
  Process { running: true; command: ["sleep", "873"] }
}
```

```bash
quickshell -p /tmp/leaktest/shell.qml &
QS=$!
sleep 3
pgrep -f 'sleep 873'      # child exists
kill -9 $QS               # die without destructors
sleep 2
pgrep -f 'sleep 873'      # still there, now reparented to systemd --user
```

## Observed

One shell instance (single Shell ID), 4437 relaunches over roughly 24 hours, driven by a lock-path crash loop while the session sat locked. That left 979 stranded `inotifywait` processes, all watching `~/.config/omarchy/plugins`, all reparented to `systemd --user`, and the user at 1025 of 1024 inotify instances.

Counting them:

```bash
find /proc/[0-9]*/fd -lname 'anon_inode:inotify' 2>/dev/null | wc -l
pgrep -u "$UID" -x inotifywait | wc -l
```

Worth noting the existing relaunch limiter in `bin/omarchy-launch-shell` does not catch this. It allows 5 relaunches per 60-second window before giving up, and resets the window on expiry. The loop I hit crashed about every 13 seconds, so `attempts` never reached 6 before `window_started` reset. A loop slower than 5/minute can run indefinitely inside the limit, which is what turned one crash into 4437.

## Proposed fix

Have the kernel do it, since it's the only thing guaranteed to run when Qt calls `_exit()`:

```qml
command: [
  "setpriv", "--pdeathsig", "TERM",
  "inotifywait", "-m", "-r", "-q",
  ...
]
```

`setpriv` is part of util-linux, so it's already present.

Tested both ways through Quickshell's real spawn path with the reproduction above (Quickshell 0.3.1, Omarchy 4.0.3):

| | child after `kill -9` of the shell |
|---|---|
| current | survives — leaked |
| with `--pdeathsig TERM` | dies with the shell |

Also verified that it doesn't regress the watcher: `inotifywait` under `setpriv` still reports `create` and `close_write` events normally, and the child was still alive after 12 seconds with the shell running, so `PDEATHSIG` isn't firing early on the spawning thread.

PR follows.

## Out of scope here

The crash that drove my loop looks like it belongs to Quickshell, not Omarchy — the shell dies in lock-surface creation when the session is locked and the compositor has no valid Wayland output (`Could not create EGL surface (EGL error 0x3000)`, then `The Wayland connection experienced a fatal error: Invalid argument`). That string isn't in this repo. This issue is only about the watcher outliving the shell, which is worth fixing regardless of what kills it.