map function : cannot move out of ... which is behind a mutable reference

I'm following this tutorial
and came across something really interesting about the map function.
Here is a toy model of the problem.

#[derive(Debug)]
pub struct Word(String);
pub fn main(){
    let words = "wwww";
    let mut word = Word(words.to_string());
    
    let mut o2 = Some(&word);

    let ref2 = &mut o2; 
    let new = ref2.map(|w|{
        "nnnnn"
    });

    println!("{:?}", new);
    println!("{:?}", o2);
}

The output is as predicted :

Some("nnnnn")
Some(Word("wwww"))

However, if I change this line

let mut o2 = Some(&word);

to

let mut o2 = Some(&mut word);

here is the error message:

error[E0507]: cannot move out of `*ref2` which is behind a mutable reference
   --> src/main.rs:10:15
    |
10  |         let new = ref2.map(|w|{
    |  _________________^____-
    | |  _______________|
    | | |
11  | | |         "nnnnn"
12  | | |     });
    | | |      ^
    | |_|______|
    |   |      `*ref2` moved due to this method call
    |   |______help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents
    |          move occurs because `*ref2` has type `Option<&mut Word>`, which does not implement the `Copy` trait
    |
note: this function takes ownership of the receiver `self`, which moves `*ref2`
   --> /home/wh/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/option.rs:919:28
    |
919 |     pub const fn map<U, F>(self, f: F) -> Option<U>
    |            

It seems like when o2 is a wrapper of some normal reference,

 o2 = Some(&word),

the map function wouldn't really try to take ownership of o2,

But, once, it is a wrapper of some mutable reference,

 o2 = Some(&mut word),

the map function suddenly wants to take ownership o2.

So the data type inside an Option could affect the behaviour of the map function,
What is the reasoning behind this?

Let's take a look at map's signature:

pub fn map<U, F>(self, f: F) -> Option<U>
where
    F: FnOnce(T) -> U

Here self is Option<T>, which causes your problem.

In statement let mut o2 = Some(&word);, the type of o2 is Option<&Word>. Thus, when you call map on it, the generic specializes to map(self, f: FnOnce(&Word) -> &str) -> Option<&str>. Only immutable references exist, and Copy is implemented for all immutable references.

But in statement let mut o2 = Some(&mut word);, the type of o2 is Option<&mut Word> and map specializes to map(self, f: FnOnce(&mut Word) -> &str) -> Option<&str>. Mutable references have no Copy implementation.

To my understanding, the immutable reference is copied, and map execute as if nothing special happened. But if a mutable reference is used, its ownership is needed since it cannot be copied.