It would be one thing if the pattern saved a lot of unnecessary code, but it doesn't. The assignment of the local variable just becomes the block variable, and you have an 'end' where the method-final return would be. Instead of a simple assignment, you now have the method invocation and the arguably more complicated block syntax.
I'll address the two particular motivations raised by the author specifically because I don't agree with either of them. First, I don't think forgetting to return the variable is a common bug. Anecdotally, I can't ever remember making this mistake myself. Even if I were to, it would be immediately obvious what the problem is. I'm open to the fact that other people perhaps make this mistake, but I'd be surprised if they routinely do. Second, I don't feel like it's obvious at all what the return value of the method is up-front, because the method invocation is confusing if you don't know what it does. Even if you do, it doesn't gain you anything you don't get by simply initializing a local at the start of the method, especially if you call the local return_value or something self-descriptive like that.
This kind of refactoring is the kind that I don't like — refactoring for the sake of refactoring, and making the code less accessible (that is, more complicated and harder to understand) for no discernible benefit.