Provide code actions to recursively expand declarative macros

Sometimes you notice that a macro DSL got out of hand and getting rid of it would actually improve the readability of the code. So it would be nice if rust-analyzer would provide code actions to selectively expand declarative macros. For example:

macro_rules! say {
    () => { concat!(say!(hello), say!(world)) }
    (hello) => { "hello " };
    (world) => { "world" };
}

fn main() {
    print!(say!(hello));
    print!(say!(world));
}

For this example the following code actions could be provided:

• code action for macro definition (e.g. macro_rules! say): expand this macro recursively everywhere it is used
• code action for macro rule definition (e.g. (hello) =>): expand this macro rule recursively everywhere it is used
• code action for macro invocation (e.g. say!(hello)): expand this macro recursively

Currently there only appears to be the Expand macro recursively command that opens the macro invocation under the cursor in a new buffer (which of course isn't helpful for large-scale refactors).

Start by examining rust-analyzer's existing “Expand macro recursively” command for macro invocations. Define how code actions on a macro definition, macro rule definition, and invocation should selectively expand recursive uses, with completion meaning the resulting source is expanded at the requested scope.