Разное поведение для одного и того же матча и блоков if let

Я пытаюсь понять, чем я обидел компилятор ржавчины, но не могу понять, что не так.

Итак, основной алгоритм:

1. Получите изменяемую ссылку на список.
2. Если следующий узел имеет значение NULL, выделите и присвойте указатель следующего узла; перерыв
3. Если следующий узел не равен нулю, получить изменяемую ссылку на следующий узел; перейти к 1

И вот как я это закодировал

fn append_at_end(&mut self, value: i32) {
    match self {
        List::Empty => {
            *self = List::new_node(value);
        },
        List::Head(head) => {
            let mut itr = head;
            loop {
                if let Some(x) = itr {
                    if x.next.is_none() {
                        x.next = Some(Node::new_node(value));
                        break;
                    } else {
                        itr = &mut x.next;
                    }
                }
            }
        }
    }
}

Теперь компилятор ржавчины жалуется на этот блок кода.

   Compiling random v0.1.0 (/Users/katharva/Personal/rust/random)
error[E0503]: cannot use `*itr` because it was mutably borrowed
  --> src/main.rs:65:28
   |
65 |                     if let Some(x) = itr {
   |                            ^^^^^-^
   |                            |    |
   |                            |    `itr.0` is borrowed here
   |                            use of borrowed `itr.0`
   |                            borrow later used here

error[E0499]: cannot borrow `itr.0` as mutable more than once at a time
  --> src/main.rs:65:33
   |
65 |                     if let Some(x) = itr {
   |                                 ^    --- first borrow used here, in later iteration of loop
   |                                 |
   |                                 `itr.0` was mutably borrowed here in the previous iteration of the loop

Some errors have detailed explanations: E0499, E0503.
For more information about an error, try `rustc --explain E0499`.
error: could not compile `random` (bin "random") due to 2 previous errors

Но тот же код, написанный как

fn append_at_end_option2(&mut self, value: i32) {
    match self {
        List::Empty => {
            *self = List::new_node(value);
        },
        List::Head(head) => {
            let mut itr = head;
            loop {
                match itr {
                    None => {}, 
                    Some(x) => {
                        // A bit convoluted but shows the bug
                        if x.next.is_none() {
                            x.next = Some(Node::new_node(value));
                            break;
                        } else {
                            itr = &mut x.next;
                        }
                    }
                }
            }
        }
    }
}

Или

fn append_at_end_option1(&mut self, value: i32) {
    match self {
        List::Empty => {
            *self = List::new_node(value);
        },
        List::Head(head) => {
            let mut itr = head;
            loop {
                if let Some(x) = itr {
                    itr = &mut x.next;
                    continue;
                } 
                
                *itr = Some(Node::new_node(value));
                break;
            }
        }
    }
}

все в порядке, компилятор этим доволен. И append_at_end_option2, и append_at_end_option1 будут работать как положено. Насколько я понимаю, все три части кода имеют одинаковую логику. Так почему же первый не приемлем?