Dispose the source info the processing creates itself

[Kentarohakase]

Stacked on #6. Not from the improvement plan — this came out of the survey that produced it, and it is a real leak rather than a cleanup.

The leak

AudioInfo subscribes to LocalizationService.Instance.PropertyChanged in its constructor so its display strings follow a language change, and it unsubscribes only in Dispose():

public AudioInfo()
{
    LocalizationService.Instance.PropertyChanged += OnLocalizationChanged;
}

LocalizationService.Instance is a process-lifetime singleton, so an AudioInfo that nobody disposes stays reachable through that subscription until the app closes.

AudioProcessingService.ProcessAsync analyses the source itself when the caller supplies none:

var sourceInfo = options.SourceInfo;
if (sourceInfo is null)
{
    var analysis = await _ffprobeService.AnalyzeAsync(...);
    ...
    sourceInfo = analysis.Value;   // assigned to a local, never disposed
}

Every run down that path left one behind. They are not merely retained: each one keeps receiving OnLocalizationChanged for every later language switch, so the cost grows with the number of runs.

The fix

The remainder of ProcessAsync moves into RenderAsync, which lets the created instance be held in a using without re-indenting ninety lines of an untested method:

var sourceInfo = options.SourceInfo;
if (sourceInfo is not null)
{
    // Supplied by the caller, so it belongs to the queue item and is disposed with it.
    return await RenderAsync(options, sourceInfo, progress, cancellationToken);
}

...
using var ownedSourceInfo = analysis.Value;
return await RenderAsync(options, ownedSourceInfo, progress, cancellationToken);

Ownership is the point of the split: an AudioInfo handed in through the options belongs to the BatchProcessingItem and must not be disposed here, so only the one created locally is.

ProcessAsync had no tests, so the extraction was verified to be a pure move — git diff -w shows nothing but the new wrapper, with the entire body from EnsureSufficientDiskSpace onward untouched.

Scope check

I looked for the same pattern elsewhere. FFprobeService and AudioDiagnosticsService create instances and hand ownership to their caller, which is correct. AudioInfo.WithSelectedAudioStream returns a new instance into BatchProcessingItem.SetAudioInfo, which disposes the previous one and is guarded by a ReferenceEquals check, so the no-streams case that returns this cannot dispose and store the same instance at once. That guard is now covered by a test, since it is load-bearing and easy to remove by accident.

A note on the new test

Dispose_StopsListeningForLanguageChanges passed in isolation but failed in the full run: it assumed the process was not already on English, and assigning the same culture raises no change at all. It now establishes a known starting culture first. Worth mentioning because it is the same class of cross-test coupling that #4 addressed — that one was a race, this one was an ordering assumption.

Verification

dotnet format .\AudioQualityEnhancer.slnx --verify-no-changes   -> clean
dotnet build  .\AudioQualityEnhancer.slnx -c Release            -> 0 warnings, 0 errors
dotnet test   .\AudioQualityEnhancer.slnx -c Release            -> 267 passed, 0 failed

No changelog entry

The leak is invisible until a long session with many runs, and no behaviour a user can point at changes.