This is a squashed commit.

This is a general list of the things that are done.

- Port common settings and commands to BuildPlugin
- Remove repeated resolvers
- Move `relaxNon212` to the build plugin
- Move build and alternative publish settings.  This commit consolidates
the build settings and the settings to set up the alternative publishing
process into the `BuildPlugin`.
- Move `noPublish` to the `BuildPlugin`
- Move the rest of the build logic to the plugin

`sbt-scalafmt` is removed because it's already brought in by
`sbt-houserules`.

We only set it up for Bintray for now.

In the future we can release to Sonatype, but we need either sbt org's
credentials or the sbt org to give us Sonatype rights to publish to
"org.scala-sbt" or change org to "ch.epfl.scala".

This build requires too much cross-compiling and cross-publishing, and
hence at the moment sbt loads all the compiler classes from all the
different versions everything starts to slow down and be close to OOMs
and SOs.

The following commit adds a jvmopts file that sets up the java flags to
be used by sbt when starting up on this repository. These jvmopts file
include:

- 1024m for the memory at startup time.
- 4086m as the maximum allocated memory for sbt.
- 512m for the code cache size (otherwise code cache becomes full and
  JDK disables C2 and fallbacks on interpreter).
- Using a bigger inline level considerably helps with compile times and
  speeds up the whole build (tested in several places).

These changes to the build allow a better workflow with scripted.

`cachedPublishLocal` is a special task that avoids publishing if an
artifact has already been published and the publication time is greater
than the changes to the source directories.

In order to find this out, `cachedPublishLocal` resolves the artifact
intransitively and in a project-specific directory. This directory is
also the used to resolve everything from scripted. This resolution is
fast because it assumes that no other task is able to publish that jar
to that concrete resolver. As a result, this assumption allows us to
remove the global dependency lock.

Running `cachedPublishLocal` in the root directory takes from 0 to 1
second. When a new change is written into a project's source file or a
resource file, `cachedPublishLocal` publishes only the project that
received the changes. This is possible because the optimizer is not
allowed and jars are independent from each other.

In this setup, `scripted` uses `cachedPublishLocal`. `scripted`
**needs** the compiler bridges for all the Scala versions, so if you
change the bridge or this is the first time you use this setup, you must
run `+compilerBridge/cachedPublishLocal`.

The following code is not necessary anymore.

- `zincPublishLocal` et al: Nobody is using the
zinc-scripted-alternative because scripted does not use sbt, it uses its
own backend.
- `scriptedUnpublished` is not necessary anymore since scripted now
relies on `cachedPublishLocal`.

In sbt 1.x, it seems that `publishArtifact` is scoped in the project and
not the build. The reason why I noticed this is because these settings
were not being applied before this change.

Eugene and Dale think this way is better, because they are not used to
the previous style that has a saner way of using scopes in Scala. They
have proposed to make the changes in an independent pull request, but I
don't have time for it.