A background service that will wait for items to process without busy-waiting
I suggest SemaphoreSlim instead of AutoResetEvent here because it has asynchronous API and will not block the current thread, and it accepts CancellationToken. Task.Yield is good hack but it can be useless because await in case of not null SynchronizationContext will restore the context and WaitOne() can anyway block the current thread.
public class ExecutionBackgroundService : BackgroundService
{
    private readonly IJob _job;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1); // 1 is concurrency degree

    public ExecutionBackgroundService(IJob job)
    {
        _job = job;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            while (true)
            {
                await _semaphore.WaitAsync(stoppingToken);
                await _job.Process();
            }
        }
        catch (OperationCanceledException ex)
        { } // occurs when WaitAsync receives canceling callback from the Token, you may log it if needed.
    }

    /// &lt;summary&gt;
    /// Notifies the background service to resume processing.
    /// &lt;/summary&gt;
    public void Resume()
    {
        lock (_semaphore)
        {
            if (_semaphore.CurrentCount == 0) // is it waiting now?
                _semaphore.Release();
        }
    }
}

This way is better because now you may cancel the Token without calling the Resume().
Btw it's a programming pattern - Producer/Consumer. The best way for moving forward is using the specially designed for this purpose almost brand-new classes - System.Threading.Channels. Refer to this link.