Make the IDR interval configurable

[ruccho]

Summary

Closes #166.

The interval between IDR (key) frames was decided entirely on the native side, and
inconsistently so:

Platform	Before
Android (MediaCodec)	KEY_I_FRAME_INTERVAL hardcoded to 1
FFmpeg	-force_key_frames expr:gte(t,n_forced*1)
WebCodecs	keyframe requested when 1 s elapsed since the previous one
Apple (VideoToolbox)	never set — encoder default
Windows (Media Foundation)	never set — encoder default

The forced one-second interval exists so that BoundedEncodedFrameBuffer can cut an exported
segment close to the requested duration. Callers that do not use that buffer —
UnboundedRecordingSession, or UniEnc used directly — pay for it without needing it.

Changes

UniEnc.VideoEncoderOptions gains float? IdrIntervalSeconds, in seconds, validated to be
finite and greater than zero when set.

null means the UniEnc default, VideoEncoderOptions.DefaultIdrIntervalSeconds (one second —
the interval every platform effectively used before this branch). It does not mean "defer to
the platform encoder": platform defaults differ per platform and can be far longer, MediaCodec
documents KEY_I_FRAME_INTERVAL as required for video encoders, and WebCodecs has no
GOP-length knob at all, so a genuine "leave it to the platform" case would have had no
consistent meaning. The native layer therefore always receives a concrete value, and each
platform applies it unconditionally.

This is not a breaking change: existing code that constructs VideoEncoderOptions without
setting the property keeps the same one-second interval it had before.

Each platform applies the value through its own knob:

• VideoToolbox — kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration. Also stored on the
  encoder input so the kVTInvalidSessionErr session-recreation path preserves it.
• MediaCodec — KEY_I_FRAME_INTERVAL, now set as a float (accepted since API 25, and
  min_api is 26) so sub-second intervals are expressible.
• Media Foundation — CODECAPI_AVEncMPVGOPSize, converted from seconds to frames using the
  frame rate hint. Applied through a new post-activation hook on Transform::new, best-effort
  so an encoder that does not implement the property still activates.
• FFmpeg — the -force_key_frames expression.
• WebCodecs — the per-frame keyframe request threshold.

On the Rust side VideoEncoderOptions::idr_interval_seconds returns a plain f32 with no
default implementation, so an implementor that omits it fails to compile rather than silently
falling back.

RealtimeEncodingOptions.Default sets one second explicitly, since that is InstantReplay's own
choice rather than something to inherit silently from UniEnc.

Note on BoundedEncodedFrameBuffer

GetFramesForDuration can only start a segment at a keyframe, and returns nothing when the
buffer holds none. Raising the IDR interval beyond the retained duration therefore produces an
empty export. Eviction is also per-frame rather than per-GOP, so frames preceding the oldest
surviving keyframe are retained but unusable, and a longer interval leaves a larger share of the
memory budget unusable. This is documented in <remarks> rather than clamped, since clamping
would be a behavioural change.

Testing

cargo check -p unienc_c passes on aarch64-apple-darwin, aarch64-apple-ios,
aarch64-linux-android, x86_64-pc-windows-msvc, x86_64-unknown-linux-gnu and
wasm32-unknown-unknown. cargo check -p unienc --tests passes, cargo fmt --check is clean,
and dotnet build -c Release succeeds for UniEnc (all three target frameworks) and
UniEnc.Example.

The Media Foundation and FFmpeg paths are verified by compilation and review only — no Windows
or Linux runtime was available.

Before merging

The native binaries under Packages/jp.co.cyberagent.instant-replay/UniEnc/Plugins/ must be
rebuilt via the build-unienc.yml workflow (manual dispatch), since VideoEncoderOptionsNative
grew from 16 to 20 bytes and the managed and native sides must be updated together.