Idea for a new code action: Turn `self`-taking methods into static methods with `self`'s accessed fields as parameters

Sometimes you need to do this to split borrows on self. Would be super neat if rust-analyzer could do it automatically.

For example, given this input:

impl Foo {
    fn whatever(&self) -> Thing {
        self.member.get_thing()
    }
}

The code action would create this output:

impl Foo {
    fn whatever(member: &TypeOfMember) -> Thing {
        member.get_thing()
    }
}

Tricky case is when the initial method calls another method on self. I guess the code action would just not be suggested in that case?

Alternatively, maybe this is really two code actions:

1. A code action to turn a self-taking method into a static method that takes a this: &Self parameter.
2. A code action to explode a struct parameter into the fields that the function body uses

Performing (1) followed by (2) is equivalent to my initial proposal, but both (1) and (2) could be useful in other situations as well.

What do y'all think?

Review the two proposed code actions and the example transformation in the issue first. Clarify whether this should be one combined action or two separate actions, and how methods that call another method on self should behave; done means an agreed scope and a tested implementation of that scope.