Add `ScalaDocumentProvider`

This class is necessary to overwrite the existing behavior of Java save
actions. Because the Java code is not extensible it is copied to the
Scala to `ScalaDocumentProvider` in order to call Scala save actions.
Start implementing API for Scala IDE extensions

This introduces several new traits in the new package

    org.scalaide.core.text

The main design goal of this text API is to provide a safe environment
users can work on. The entire API can't change the underlying documents,
it can only produce change objects that need to be passed to the IDE,
which can decide what to do with the changes.
Add save action support

This adds support to execute save actions in the
`ScalaDocumentProvider`.
Add remove trailing whitespace save action
Add new methods to Document API

Common methods are added: apply, head, tail, init, last (+ safe variants
that return an Option)
Add save action that adds new line at end of file
Add compiler support for save actions

It is now possible to choose if a save action should operate only on
a low level text API or on the entire API of the compiler.
Add save action setting functionality

This is an API extension that allows save action authors to show
information about the save action to users.
Add setting support to `RemoveTrailingWhitespace`
Add setting support for `AddNewLineAtEndOfFile` save action
Add preference page for save actions
Add preference initializer for save actions
Implement setting functionality in `ScalaIdeExtension`

This allows the logic that executes the save actions to filter out all
save actions that are disabled.
Sort save actions by name in preference page
Simplify `SaveActionSetting`

The properties `textBefore` and `textAfter` are replacey by
`codeExample`. The reason for this is that it is more useful when the
IDE computes the changes a save action is doing instead of hardcoding an
example into the sources.

However, without the ability to create save actions at runtime, this
functionality can't be implemented yet because we can't inject
dependencies easily into the save action instance.
Add save action for auto formatting
Change evaluation order of save actions

Previously, all save actions were first executed, then there produced
changes were combined and then the combined changes were applied to the
document.

This evaluation order is not correct, because it must be possible to
evaluate each save action at any given moment, regardless if other save
actions are executed beforehand or not. Furthermore, combining changes
means that we could get overlapping change regions.

These problems are solved in so far that immediately after execution of
the save action its calculated changes are applied to the document.
Make execution of save actions more safe

Every save action is wrapped in a safe environment that catches errors.
Add save action that adds missing override keywords

Only works with defs and types, but not yet with vals.
Make save action computation async but don't abort them

Async save actions allows to return after a given timeout. Because the
API of the save actions doesn't provide a way to cancel further
computations of the save action once it timed out, the save action must
complete.

If it does not it will consume CPU and memory and the best seems to be
to restart Eclipse.