How does it takes place in the Software development process and how far it effects the system?
Merciless refactoring is a standard practice in all teams I work with. The emphasis is on 'merciless'. If code doesn't 'feel' right it probably isn't. Typically this is called a 'code smell'.
In general we refactor as soon as possible, typically at a time when all tests pass. We stop refactoring once we cannot think of any further way to simplify the code.
Sometime we refactor towards a particular design pattern, e.g. when we have identified the need for a particular interface. Sometimes we change the implementation to address a performance issue. In that sense there are cases when refactoring affects the system. In general however, our refactorings do not change the systems behavior.
Does Refactoring using these tools really speed up the process of development/maintenance?
The best option would be to have data to answer this question. I don't. However, based on observation in my experience fully refactored code is much easier to work with. It is easier to extend. It is easier to locate the source of a bug. By removing code duplicates you not only follow the DRY principle (Don't Repeat Yourself) but you also avoid having to fix the same bug more than once.
Using tools is mandatory. Manual refactoring is possible but tools can take care of most of the cases and are a real time saver.
Based on my observations and my experience working with a number of teams and systems refactoring supported by tools speeds up both development and maintenance of source code.