Move common functionality from Fires and MethodCalls to
ScopedTraverser, which provides the ability to loop recursively
through AST tree while keeping track of the variables bound
to `this`.

First off it's just a Js::MethodCalls class that's not yet
connected to JSDuck.

Rewrite the AST-traversing algorithm in a more generic way -
just looping over all the subtrees without having the actual
knowledge of what fields make sense to recurse into.

Looks for this.fireEvent("blah") inside function body.
Also understands me.fireEvent("blah") when me has been
assigned with `this`.

Log warning when unknown event name is used.

For documenting events thrown by a method.

Related to issue: #364

Previously the order was pretty-much random.

Leave just small stars behind new classes.  This way it's lot
less cluttered.

The new "New in this version" section covers the details of
what's new much better and doesn't get on the way.

The docs for accessors get auto-generated and we need nothing extra.
Having the :inheritdoc in there also causes errors when looking up
the parent.  For example the following:

    /**
     * @cfg {Number} width
     * @inheritdoc SomeClass#width
     * @accessor
     */

When the accessors would get the @inheritdoc, this would look like
we had the following methods:

    /**
     * @method getWidth
     * @inheritdoc SomeClass#width
     */

    /**
     * @method setWidth
     * @inheritdoc SomeClass#width
     */

But the inheritance system would attempt to inherit the docs from
"width" method, but there is no such thing because we were actually
inheriting from "width" config.

Therefore we're better off without the whole @inheritdoc in accessors.

Related to: #365

Instead of having the class names in headers be the links.

Use the Columns class to do the splitting in exactly the same way
as in Categories.

Let it manage the columns splitting logic so we can also share it
with new items list.

Handle the :autodetected field entirely inside Merger class.

From code we get the :autodetected hash with :tagname value - we
use this as the initial value for :autodetected field in merge result.
By adding this, we eliminate the need for the special merge logic
in Autodetected class (which turned out to be buggy anyway).

Call the Merger.can_be_autodetected? from Param tag.

Move the methods in it to Merger.

Stick with the simple: if @param in comment, use that, otherwise
use params auto-detected from code.  This means the auto-merging
takes completely care of that.  So the merge method only needs to
set the defaults and report warnings.

This change eliminates support for the syntax where one defines
variabled types in doc-comment and names in code.  But that's a
very silly syntax anyway as one can't use it when one also wants
to document the variable.  So it's now gone and we have simplified
the code considerably.

For this make Ast detect no params as nil instead of [].
Similarly detect no explicit params as nil not [].
This allows the auto-merging to pick the one with some params
and use that plus mark params :autodetected when merged from code.

But the actual merging of params is still done in Param class
because of the complicated types merging logic.

Additionally refactored the param warnings creation to separate
method.

Run the custom #merge methods only to do post-processing after
the automerging has completed.

Generally this means the #merge method is now mainly responsible
for setting the default value.

This eliminates the clunky calls to DocsCodeComparer class.

Let the auto-merging algorithm take care of this.

Change the generic merging algorithm to merge all non-nil fields.
Previously it checked for #key_exists? but in the case of :default
the key existed but defaulted to nil.

Move name-detection to merger class and get rid of Tag::Name class
completely.

Instead of modifying the passed-in hash, the method now creates
a hash by its own and returns it.

Instead of just returning the hash, process_code will now add fields
To the supplied context hash, with implementation in MemberTag covering
the base case and subclasses adding their extra logic on top of that.

Transformation of member name from "foo.bar.baz" to "baz" now
happens within MemberTag#process_code, while Class#process_code leaves
the name as is.

The #process_code now gets called for every time - both when the member
type was detected correctly and when it was not.