ВСЕГДА ли использование `std::sync::Mutex` в точке `await` вызывает взаимоблокировку?

Хотя я прочитал весь ОП, ответ и комментарии Почему у меня возникает взаимоблокировка при использовании Tokio с std::sync::Mutex?, я пока не понимаю, почему код в ОП блокируется навсегда.

Вот слегка измененная версия исходного кода:

use std::sync::Arc;
use std::sync::Mutex;
// use tokio::sync::Mutex;
use tokio::time::Duration;

async fn f(mtx: Arc<Mutex<i32>>, index: usize) {
    println!("{}: trying to lock...", index);
    {
        let mut v = mtx.lock().unwrap();
        // let mut v = mtx.lock().await;
        println!("{}: locked", index);
        tokio::time::sleep(Duration::from_millis(1)).await;
        *v += 1;
    }
    println!("{}: unlocked", index);
}

#[tokio::main]
async fn main() {
    let mtx = Arc::new(Mutex::new(0));
    tokio::join!(f(mtx.clone(), 1), f(mtx.clone(), 2));
}

Результат:

1: trying to lock...
1: locked
2: trying to lock...

(and blocks forever...)

Судя по ответу и комментариям (и если я их правильно прочитал), причина в том, что весь код выполняется в однопоточной среде. Если выделенная курсивом часть соответствует действительности, я могу понять поведение блокировки. Однако я не понимаю, действительно ли выделенная курсивом часть соответствует действительности.

Насколько я понимаю,

• среда выполнения Tokio по умолчанию является многопоточной, если вы явно не укажете #[tokio::main(flavor = "current_thread")] (источник)

• а выполненные await задачи можно автоматически переместить в другой рабочий поток (источник ).

Поэтому я думаю, что код НЕ блокируется, если задачи (т. е. f(mtx.clone(), 1).await, f(mtx.clone(), 2).await и sleep(...).await) выбраны (средой выполнения Tokio) для выполнения в разных потоках, но код выглядит блокирующим, поскольку среда выполнения выбирает, все задачи выполняются в та же самая нить.

Верно ли мое понимание?