Extract MemberTag class.

Require all member classes to be subclasses of this.
Add #process_code method to MemberTag class.

Also implement it on JsDuck::Tag::Class, although it's not a member.

The #process_code will extract data from code that's relevant to the
current member type.
Change #process_code to take two params.

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.
Refactor #process_code to take just one param again.

Instead of modifying the passed-in hash, the method now creates
a hash by its own and returns it.
Don't auto-merge code when names don't match.

Move name-detection to merger class and get rid of Tag::Name class
completely.
Mark all auto-merged fields as auto-detected.
Remove #merge method from Default tag 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.
Use auto-merging for everything.

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.
Mark params autodetection in generic way.

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.
Eliminate the complex parameter merging logic.

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.
Eliminate DocsCodeComparer class.

Move the methods in it to Merger.
Eliminate duplication of can_be_autodetected? method.

Call the Merger.can_be_autodetected? from Param tag.