I think the difference is between moving and reborrowing, the latter of which is honestly not well documented although the semantics work intuitively in many/most cases, but I'm not sure why the addition of a type annotation is what makes the difference. Probably it's about the fact that every time you write & (mut) T it actually means &'a (mut) T for some compiler-assigned lifetime a.
I believe its related to type inference. The same way, a mutable reference passed to a function expecting &mut … reborrows, while passed to a generic function that takes any type, it drops it.
The logic might be something like: reborrow when you know you have a (mutable) reference type, otherwise move. Only after a move is decided, this move is used in type inference to figure out the connection between the types, and infer the types. Once it knows there's a mutable reference, its too late to switch to re-borrowing. Or something like that... just a guess though