Ключевым моментом является то, что вам нужно как-то извлечь Option<&'a mut T> из &'b mut IterMut<'a, T>.

Чтобы понять, почему IterMut<'a, T> := &'a mut Link<T> не может работать, нужно понять, что именно можно делать с изменяемой ссылкой. Ответ, конечно, почти все. Вы можете копировать из него данные, изменять их значение и многое другое. Единственное, что вы не можете сделать, это признать его недействительным. Если вы хотите переместить данные по изменяемой ссылке, их необходимо заменить чем-то того же типа (включая время жизни).

Внутри тела next, self находится (по существу) &'b mut &'a mut Link<T>. Если мы не знаем что-то о T (а мы не можем в этом контексте), просто невозможно получить из этого что-то типа &'a mut Link<T>. Например, если бы это было вообще возможно, мы могли бы сделать

fn bad<'a, 'b, T>(_x: &'b mut &'a mut T) -> &'a mut T {
    todo!()
}

fn do_stuff<'a>(x: &'a mut i32, y: &'a mut i32) {
    // lots of stuff that only works if x and y don't alias
    *x = 13;
    *y = 42;
}

fn main() {
    let mut x: &mut i32 = &mut 0;
    let y: &mut i32 = {
        let z: &mut &mut i32 = &mut x;
        bad(z)
    };
    // `x` and `y` are aliasing mutable references
    // and we can use both at once!
    do_stuff(x, y);
}

(ссылка на игровую площадку)

Дело в том, что если бы мы могли заимствовать что-то на короткое (общее) время жизни 'b и возвращать что-то, что позволяло модифицировать в течение более длительного времени жизни 'a, мы могли бы использовать несколько коротких сроков жизни (более короткие чем 'a и непересекающиеся), чтобы получить несколько изменяемых ссылок с одинаковым временем жизни 'a.

Это также объясняет, почему работает неизменяемая версия. С неизменяемыми ссылками переход от &'b &'a T к &'a T тривиален: просто скопируйте неизменяемую ссылку. Напротив, изменяемые ссылки не реализуют Copy.

Поэтому, если мы не можем произвести &'a mut Link<T> из &'b mut &'a mut Link<T>, мы, конечно же, не можем получить из него Option<&'a mut T (кроме None). (Обратите внимание, что мы можем создать &'b mut Link<T> и, следовательно, Option<'b mut T>. Это то, что сейчас делает ваш код.)

Так что же работает? Помните, что наша цель — получить Option<&'a mut T> из &'b mut IterMut<'a, T>.

Если бы мы могли создать IterMut<'a, T> безусловно, мы могли бы (временно) заменить self им и, следовательно, иметь прямой доступ к IterMut<'a, T>, связанному с нашим списком.

// This actually type-checks!
fn next<'b>(&'b mut self) -> Option<&'a mut T> {
    let mut temp: IterMut<'a, T> = todo!(); // obviously this won't work
    std::mem::swap(&mut self.0, &mut temp.0);
    temp.0.as_mut().map(|node| {
        self.0 = &mut node.next;
        &mut node.elem
    })
}

(ссылка на игровую площадку)

Самый простой способ настроить все так, чтобы все это работало, это немного транспонировать IterMut<'a, T>. Вместо того, чтобы иметь изменяемую ссылку вне опции, сделайте ее внутри! Теперь вы всегда сможете создать IterMut<'a, T> с None!

struct IterMut<'a, T>(Option<&mut Box<Node<T>>>);

Переводя next, получаем

fn next<'b>(&'b mut self) -> Option<&'a mut T> {
    let mut temp: IterMut<'a, T> = IterMut(None);
    std::mem::swap(&mut self.0, &mut temp.0);
    temp.0.map(|node| {
        self.0 = node.next.as_mut();
        &mut node.elem
    })
}

Более идиоматически, мы можем использовать Option::take, а не std::mem::swap (это упоминалось ранее в Слишком много связанных списков).

fn next<'b>(&'b mut self) -> Option<&'a mut T> {
    self.0.take().map(|node| {
        self.0 = node.next.as_mut();
        &mut node.elem
    })
}

(ссылка на игровую площадку)

На самом деле это немного отличается от реализации в Слишком много связанных списков. Эта реализация удаляет двойную косвенность &mut Box<Node<T>> и заменяет ее простым &mut Node<T>. Однако я не уверен, сколько вы выиграете, так как эта реализация все еще имеет двойное отключение в List::iter_mut и Iterator::next.