feat: add Audio Unit plugin support for per-app and per-device effects

Enable third-party and system AU effect plugins to be loaded and applied
to individual applications or output devices, similar to SoundSource.

Audio pipeline:
- Non-interleaved stereo rendering with pre-allocated deinterleave buffers
- RT-safe AU hosting via AudioUnitRender with monotonic sample time tracking
- Immutable AUEffectChain with atomic swap + deferred destruction (500ms)
- Signal flow: EQ → AutoEQ → [Per-App AU] → [Per-Device AU] → Loudness → Limiter
- Tail time tracking for reverb/delay effects (continues rendering after silence)
- Crossfade support with independent AU instances per tap
- Device AU chains reload correctly on device switch

Plugin management:
- AUPluginScanner discovers kAudioUnitType_Effect and kAudioUnitType_MusicEffect
- Live detection via kAudioComponentRegistrationsChangedNotification
- Factory preset enumeration and selection per effect
- AU parameter state persisted on window close and app quit (ClassInfo plist)
- Crash guard integration: FNV-1a hash tracking, crash file write via POSIX,
  auto-disable offending plugins on next launch
- Full persistence: per-app chains, per-device chains, bypass state, favorites,
  crash history

UI:
- Hierarchical plugin picker with search, favorites (with namespaced ForEach IDs),
  and crash warnings
- Effect chain view with enable/disable, bypass, factory presets, remove
- Failed plugin instantiation shown with warning icon
- AUGenericView floating windows for parameter editing
- Device FX button with ExpandableGlassRow integration

Architecture:
- AUChainState model consolidates entries, bypass, and failedEntryIDs
- AudioEngine owns observable AU state (appAU/deviceAU dictionaries);
  SettingsManager handles persistence only
- Favorites and crash history use @Observable-tracked closures for views,
  with @State in popover content (NSPanel observation boundary)

Includes 45 unit tests covering descriptor codable, scanner discovery,
AU instantiation, RT rendering (lowpass attenuation, reverb tail),
bypass passthrough, settings persistence, and crash history.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: iscle

FineTune/Audio/AUPlugins/AUEffectChain.swift

@@ -0,0 +1,95 @@
+// FineTune/Audio/AUPlugins/AUEffectChain.swift
+import Foundation
+import os
+
+/// Immutable ordered chain of AU effect hosts.
+///
+/// When the chain changes (add/remove/reorder), build a new `AUEffectChain` and
+/// atomically swap the pointer in `ProcessTapController`, then defer-destroy the
+/// old chain after 500ms. Same pattern as `LoudnessEqualizer`.
+///
+/// ## RT-Safety
+/// `process()` runs on CoreAudio's HAL I/O thread. Reads `_hosts`/`_hostCount`/`_isBypassed`
+/// which are set once at init (except bypass, toggled from main thread).
+final class AUEffectChain: @unchecked Sendable {
+
+    let entries: [AUEffectChainEntry]
+    let failedEntryIDs: Set<UUID>
+
+    private let _hosts: [AUEffectHost]
+    private let _hostCount: Int
+    private nonisolated(unsafe) var _isBypassed: Bool = false
+
+    private let logger = Logger(subsystem: "com.finetuneapp.FineTune", category: "AUEffectChain")
+
+    var isBypassed: Bool { _isBypassed }
+
+    var maxTailTime: Double {
+        var maxTail: Double = 0
+        for host in _hosts where host.isEnabled {
+            if host.tailTimeSeconds > maxTail {
+                maxTail = host.tailTimeSeconds
+            }
+        }
+        return maxTail
+    }
+
+    var hosts: [AUEffectHost] { _hosts }
+
+    func host(for entryID: UUID) -> AUEffectHost? {
+        _hosts.first { $0.entryID == entryID }
+    }
+
+    init(entries: [AUEffectChainEntry], sampleRate: Double, maxFrames: UInt32 = 4096) {
+        self.entries = entries
+        var hosts: [AUEffectHost] = []
+        var failed = Set<UUID>()
+        for entry in entries {
+            let host = AUEffectHost(
+                descriptor: entry.pluginDescriptor,
+                entryID: entry.id,
+                sampleRate: sampleRate,
+                maxFrames: maxFrames,
+                enabled: entry.isEnabled
+            )
+            if host.instantiate() {
+                if let presetData = entry.presetData {
+                    _ = host.loadPreset(presetData)
+                } else if let presetIndex = entry.selectedFactoryPresetIndex {
+                    _ = host.selectFactoryPreset(index: presetIndex)
+                }
+                hosts.append(host)
+            } else {
+                failed.insert(entry.id)
+                logger.error("Failed to instantiate \(entry.pluginDescriptor.name), skipping")
+            }
+        }
+        self.failedEntryIDs = failed
+        self._hosts = hosts
+        self._hostCount = hosts.count
+
+        for host in hosts {
+            CrashGuard.trackPlugin(host.descriptor.id)
+        }
+
+        logger.info("Created AU effect chain with \(hosts.count)/\(entries.count) plugins at \(sampleRate)Hz")
+    }
+
+    // MARK: - Bypass
+
+    func setBypassed(_ bypassed: Bool) {
+        _isBypassed = bypassed
+    }
+
+    // MARK: - RT-Safe Processing
+
+    /// Process interleaved stereo samples through the entire AU chain in-place.
+    @inline(__always)
+    func processInterleaved(samples: UnsafeMutablePointer<Float>, frameCount: Int) {
+        guard !_isBypassed else { return }
+        let count = _hostCount
+        for i in 0..<count {
+            _hosts[i].renderInterleaved(samples: samples, frameCount: frameCount)
+        }
+    }
+}

FineTune/Audio/AUPlugins/AUEffectChainEntry.swift

@@ -0,0 +1,26 @@
+// FineTune/Audio/AUPlugins/AUEffectChainEntry.swift
+import Foundation
+
+struct AUEffectChainEntry: Codable, Identifiable, Equatable {
+    let id: UUID
+    let pluginDescriptor: AUPluginDescriptor
+    var isEnabled: Bool
+    var presetData: Data?
+    var selectedFactoryPresetIndex: Int?
+
+    init(plugin: AUPluginDescriptor, isEnabled: Bool = true) {
+        self.id = UUID()
+        self.pluginDescriptor = plugin
+        self.isEnabled = isEnabled
+        self.presetData = nil
+        self.selectedFactoryPresetIndex = nil
+    }
+}
+
+/// Observable UI state for a single AU effect chain (per-app or per-device).
+/// AudioEngine owns these; SettingsManager persists entries + bypass to disk.
+struct AUChainState {
+    var entries: [AUEffectChainEntry] = []
+    var isBypassed: Bool = false
+    var failedEntryIDs: Set<UUID> = []
+}