The only easy to implement solution I found was using SemaphoreSlim like suggested here. It’s also the general solution to the problem.

It can e.g. be implemented via inheritance to the ImapClient:

using MailKit.Net.Imap;

/// <remarks>
/// Using multiple instances of <see cref="MailKit.Net.Imap.ImapClient"/> to connect to the same mailbox at the same time is very likely to cause issues.
/// This is because an IMAP server simply refuses to take new commands when it is currently busy executing another command. To make a single ImapClient instance
/// accessible throughout the app, to be used by multiple concurrent Tasks, we can restrict access to it by using a semaphore that can be locked and released
/// before and after using the ImapClient.
/// </remarks>
/// <inheritdoc cref="ImapClient"/>
public interface IImapClientWithSemaphore : IImapClient
{
    /// <summary>
    /// <b>Always</b> wait for the semaphore before executing any relevant command. See <see cref="IImapClientWithSemaphore"/> for a detailed explanation on why.
    /// </summary>
    public SemaphoreSlim Semaphore { get; }
}

Implemented like this:

/// <inheritdoc cref="IImapClientWithSemaphore"/> />
public class ImapClientWithSemaphore : ImapClient, IImapClientWithSemaphore
{
    /// <inheritdoc cref="IImapClientWithSemaphore"/> />
    public SemaphoreSlim Semaphore { get; } = new(1, 1);

    /// <inheritdoc cref="ImapClient"/> />
    public ImapClientWithSemaphore() { }

    /// <inheritdoc cref="ImapClient"/> />
    public ImapClientWithSemaphore(IProtocolLogger protocolLogger) : base(protocolLogger) { }
}

You can then just do this:

await imapClient.Semaphore.WaitAsync(CancellationToken.None);

try
{
    await imapClient.GetFolderAsync(/* ... */)
}
finally
{
    imapClient.Semaphore.Release();
}