Interrupt Scala builder on resource change

Whenever Eclipse is configured to automatically build, an interrupt
event is sent to all builders whenever an resource change happens in the
workspace.

The Scala builder didn't react on such an interrupt event so far - this
changes with this commit.

Beside from aborting the current running build, the build is restarted
after the resource change event is handled.

Fixes #1002229
Merge pull request #767 from sschaef/t1002229-interrupt-build

Interrupt Scala builder on resource change
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.