Restore spell checking functionality for the Scala editor

This comes with a lot of overhead of classes that delegate the reported
spelling errors as problems to the underlying core. In the following an
explanation why the new design is complicated:

First, spell-checking needs to be an editor independent service, this is
because we don't want to check everything but only some parts of code
(partitions) - for Java it would be comments and strings. For Scala we
also need support for multi line strings, which the Java spelling engine
can't obviously provide.

The problem with the SpellingEngine class of Eclipse is, that it is not
able to provide spelling engines for a particular editor (as it should
be done), it can only provide one spelling engine that is globally
available for the entire Eclipse platform. Because JDT already provides
we can't simply provide our own one, because this would mean that
Eclipse has to choose between one of them. The algorithm is that the
chosen one is the first one that is found, which is the one from JDT
because its plugin is loaded before our own.

The previous, aspect driven implementation solved this ordering problem
by hooking into the internals and replacing a reference to the JDT
spelling engine with a reference to our own spelling engine. This worked
fine in the past and would also work fine in future, but it has a flaw:
It means that the Java editor also uses the Scala spelling engine since
the moment when the Scala IDE plugin is installed (and this basically
means that we would break their spelling support if our own is broken).

This PR goes a different way: It removes the aspect driven code but
inserts another implementation of SpellingService, which only uses the
spelling engine that is configured (our own). The advantage is that the
Scala editor is completely independent from other configured spelling
engines and that our own spelling engine doesn't interfere with other
editors. Disadvantage is that we can't use other spelling engines
defined in the system anymore, but because no one beside from ourself
would ever provide a spelling engine that fully supports the Scala
syntax I don't think this disadvantage matters.

Fixes #1002123
Remove unused spelling provider

This code is no longer necessary because the spelling engine is now
configured in `ScalaSourceViewerConfiguration`.
Remove unused progress monitor from `ScalaReconcilingStrategy`
Remove dependency to internal JDT spelling engine
Fix compiler warning about unused import

The warning occurs due to bug SI-8808 - the rename hides it.
Unify kepler and luna branches as different profiles under the same build.

This commit “merges” the platform/luna branch into master, using separate
source folders for the source-incompatible differences between the two platforms.
In this way we don’t need to regularly merge master into Luna, and it makes it
easier to use Luna for developing the IDE itself.

* Changes that proved to be source-compatible, but only added in Luna, I
  merged them as-is (without relying on a separate source dir for those)
* jdt.core versions in the manifest file are now replaced when they are
  copied using the maven-antrun plugin. The substitution is performed automatically,
  but the syntax is slightly different than for pure maven resources. It’s
  not ideal but there is no way to both substitute variables and rename a given
  file.
* I made src-luna be the default in project definitions.
Use a full version range for jdt.core dependency.
Add org.eclipse.osgi bundle to manifest file.

Fixed #1002211.
Merge pull request #758 from sschaef/t1002123-spell-checker

T1002123 spell checker
Merge pull request #769 from dragos/unify-luna

Unify kepler and luna branches as different profiles under the same build
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