Significado dos símbolos "e" e "e" estrela "*" em Rust

Apesar de ler atentamente a documentação, estou um pouco confuso sobre o significado do& e* símbolo no Rust e, mais geralmente, sobre o que é exatamente uma referência ao Rust.

Neste exemplo, parece ser semelhante a uma referência C ++ (ou seja, um endereço que é automaticamente desreferenciado quando usado):

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = rc + 1;
    println!("{}", next); // 6
}

No entanto, o código a seguir funciona exatamente da mesma maneira:

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = *rc + 1;
    println!("{}", next); // 6
}

Usando* desreferenciar uma referência não estaria correta em C ++. Então, eu gostaria de entender por que isso está correto no Rust.

Meu entendimento até agora é que, inserindo* na frente de uma referência Rust a desreferencia, mas o* é inserido implicitamente de qualquer maneira, para que você não precise adicioná-lo (enquanto em C ++, ele é inserido implicitamente e, se você o inserir, receberá um erro de compilação).

No entanto, algo assim não compila:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = rc + 1;
    }
    println!("{}", next);
}

error[E0369]: binary operation `+` cannot be applied to type `&mut i32`
 --> src/main.rs:6:16
  |
6 |         next = rc + 1;
  |                ^^^^^^
  |
  = note: this is a reference to a type that `+` can be applied to; you need to dereference this variable once for this operation to work
  = note: an implementation of `std::ops::Add` might be missing for `&mut i32`

Mas isso funciona:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = *rc + 1;
    }
    println!("{}", next);  // 6
}

Parece que a desreferenciação implícita (à la C ++) está correta para referências imutáveis, mas não para referências mutáveis. Por que é isso?