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