- Update WaveformControllerEvents type to allow Promise<void> return
- Await onApprove callback in useWaveformController

- Mark all onApprove callback invocations with void operator
- Ensures promises are explicitly handled per linting rules

Change the onApprove callback signature from `void | Promise<void>`
to always return `Promise<void>` for API consistency.

Changes:
- Update WaveformControllerEvents type signature
- Make AudioInput onApprove implementation async with await
- Update test type annotations

This provides a consistent async interface and prevents bugs from
assuming synchronous behavior when the callback may be async.

Remove the internalMountRef fallback and make containerRef required
in useWaveformController to maintain architectural consistency with
ChatInput.

Changes:
- Remove internalMountRef and fallback logic
- Make containerRef required in UseWaveformControllerParams
- Replace all mountRef references with containerRef
- Return containerRef as mountRef in the controller interface

This maintains API compatibility while enforcing consistent ref
management patterns across the codebase.

Add vertical padding to StyledWaveSurferDiv to restore spacing that
was previously baked into the height calculation when switching from
explicit height to 'auto'.

Changes:
- Add paddingTop and paddingBottom using theme.spacing.threeXS
- Replaces the previous approach where WAVEFORM_PADDING was included
  in the height calculation (height = WAVEFORM_HEIGHT + WAVEFORM_PADDING)

This properly separates concerns - WaveSurfer handles waveform
dimensions while CSS handles spacing.

Remove the throw and .catch() pattern that was causing errors to be
reported twice - once in initializeWaveSurfer's catch block and again
in the useEffect's catch handler.

Changes:
- Remove throw from initializeWaveSurfer catch block
- Remove .catch() from useEffect
- Handle errors once in initializeWaveSurfer where they occur

This creates a single, clear error handling point and prevents
duplicate error reporting to the onError callback.

All WaveformControllerEvents callbacks now consistently return Promise<void>
instead of mixing void and Promise<void> return types. This provides a more
predictable API and aligns with modern async/await best practices where
"always async" is preferred over "sometimes async".

The lastStopResultRef was caching stop results as a defensive fallback for:
1. Returning cached results when stop() called repeatedly
2. Providing fallback blob in approve() when state is cleared

This is overly defensive and hides bugs in state management. If stop() is
called when not recording, that's a bug. If approve() can't find the blob,
that's also a bug. Both should fail loudly rather than return stale data.

Simplified approach:
- stop() now throws immediately if not recording
- approve() uses blob parameter or currentBlob only
- Removed all lastStopResultRef cleanup code

This forces proper state management and makes bugs visible.

Replaced all `MockRecordPluginClass as any` assertions with
`MockRecordPluginClass as unknown as typeof RecordPlugin` to be more
explicit about the type we're casting to.

While still a type assertion, this is more specific and documents what
type the mock is pretending to be, rather than completely bypassing
type safety with 'as any'.

Also removed the eslint-disable-next-line comments that were suppressing
the no-explicit-any rule, since we're no longer using 'as any'.

Add missing RecordPlugin type import to WaveSurferRecordBackend.test.ts.
The type was referenced in type assertions (typeof RecordPlugin) but
never imported, causing CI type check failures.

Resolves 25 ESLint violations that were blocking CI:

**AudioInput.tsx (8 fixes):**
- Add return Promise.resolve() to async callbacks that don't await
- Satisfies @typescript-eslint/require-await rule
- Callbacks: onPermissionDenied, onError, onRecordStart, onRecordReady,
  onCancel, onProgressMs, onPlaybackPause, onPlaybackFinish
- Maintains Promise<void> interface contract while avoiding unnecessary
  async overhead

**AudioInput.test.tsx (17 fixes):**
- Add void operator to unhandled promise calls
- Satisfies @typescript-eslint/no-floating-promises rule
- Makes explicit that promises are intentionally not awaited
- Matches pattern used in useWaveformController implementation

These changes maintain the architectural decision (commit 56221c8d0) to
have all WaveformControllerEvents callbacks return Promise<void> for
API consistency, while satisfying linting requirements.

No behavior changes - callbacks already worked correctly.

Only onApprove is truly async (handles encoding/uploading), so it's the
only callback that should return Promise<void>. All other callbacks are
synchronous (just set React state) and now correctly return void.

This eliminates unnecessary async wrappers and Promise.resolve() calls.