.ensime template for compiler development

Provides a template of an .ensime file to be used for compiler hacking
together with an ENSIME-enabled text editor.

Also includes a readme that outlines what editors support ENSIME.
To the best of my knowledge these are Emacs, TextMate, jEdit and Sublime Text 2
Rewrite of transformTypeTagEvidenceParams.

This fixes what a bug where the prefix seems to be checked but
is ignored; however I rewrote this method purely out of a desire
for tighter code.  I would consider it a great personal
favor if you would study the before/after and endeavor to
internalize the mechanisms I applied.

Points of particular note:

 - Before you write Option[Symbol], remember we already have
   an Option[Symbol], and it's Symbol.  None == NoSymbol.
 - flatMap can be to an Option, you don't have to create a
   one element List for flatMap's enjoyment
 - lastOption and headOption are rarely the way to go
   ... especially if you start with if (xs.isEmpty) return
 - The method which checks for emptiness is ".isEmpty",
   it is NOT ".length == 0"

I should add a pattern matcher warning for when you have a lower
case name in scope (like "contextParam") and then use a lower case
pattern variable of the same name, which of course ignores the
one outside the pattern and matches everything.

Review by @xeno-by.
SI-5940 impls are no longer in macro def pickles

The first officially released version of macros persisted
macro def -> impl bindings across compilation runs using a neat trick.

The right-hand side of macro definition (which contains a reference to an impl)
was typechecked and then put verbatim into an annotation on macro definition.

This solution is very simple, but unfortunately it's also lacking. If we use it
then signatures of macro defs become transitively dependent on scala-reflect.jar
(because they refer to macro impls, and macro impls refer to
scala.reflect.macros.Context defined in scala-reflect.jar).
More details can be found in https://issues.scala-lang.org/browse/SI-5940.

Therefore we have to avoid putting macro impls into binding pickles and
come up with our own serialization format. Situation is further complicated
by the fact that it's not enough to just pickle impl's class and method names,
because macro expansion needs knowledge about the shape of impl's signature
(which we can't pickle). Hence we precompute necessary stuff (e.g. the layout
of type parameters) when compiling macro defs.
macro implementations must be public

The immediate motivator for this change was the desire to keep things simple
during macro expansion.

Here's the story. When you expand a macro, you need to reflectively load
a macro implementation method and invoke it. However private methods in Scala
can sometime have their names mangled, so the reflector has to check multiple
variants of the same name (the normal one and the mangled one).

The problem is that since the previous commit we don't have an access to a
symbol of the macro impl, hence we cannot just use `impl.expandedName` like
we did before. Sure I could duplicate the logic of expandedName, but I have
a better suggestion.

Let's prohibit non-public macro implementations. This doesn't seem to hurt,
and it lets us avoid extra bit of complexity in Macros.scala.

If this measure turns out to be a hassle during the trial period of macros,
non-public macros can always be allowed. In fact, we can even have this feature
back for free when we migrate from Java reflection to Scala reflection for
invoking macro implementations (because Scala reflection knows how to account
for mangled private names). But that's the 2.10.x business.
accommodated the feedback for the pull request

For the discussion see: https://github.com/scala/scala/pull/1101
don't crash on unsupported pattern -- diagnose
Merge pull request #1101 from scalamacros/ticket/5940

SI-5940 impls are no longer in macro def pickles
don't catch StackOverFlowError: kills performance

instead, use a recursion counter in negationNormalForm as in conjunctiveNormalForm
(except we only limit recursion depth, not formula-size
 reuse the same config variable in hopes it'll do for both)
Add Scaladoc flag to specify hidden implicit conversions
Merge pull request #1134 from adriaanm/patmat-misc

patmat tweaks: compiler performance, better error on unsupported pattern
Merge pull request #1136 from ingoem/scaladoc/implicits2.10

Add Scaladoc flag to specify hidden implicit conversions
Merge pull request #1137 from scalamacros/topic/ensime

.ensime template for compiler development