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.

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.

Require all member classes to be subclasses of this.

Split the Render::Signature into two classes:

 - MethodSignature
 - PropertySignature

And add a third one for a shared method for generating the link:

 - SignatureUtil

All the builtin member classes now have #to_html method which
takes two parameters (differently from the normal #to_html that
only takes one).  This probably can't stay this exact way.

By using just the name "eOpts" we can't really be sure if the
parameter was auto-inserted or manually added by user.

Ignore the auto-inserted eOpts parameter.

Also print a warning when the first and only property uses
namespaced subproperty syntax.

Additionally truncate the name of the first property to
remove anything after the dot.

So that when somebody writes:

  /** @cfg foo.bar */

We print a warning and treat it as if he had written:

  /** @cfg foo */

Fixes: #341

Improve the documentation significantly.

Now the messy part is contained in the InheritMembers class.

Ruby 1.8 doesn't understand that we have loaded this class already
and will re-load it and then give warnings.

Instantiate the TagRegistry in Options class to prevent instantiation of
it when we're running the code in parallel forks.

When no explicit staticality stated, try to first inherit from instance
members.  Only when that fails look for static members too.

Converting auto-detected properties into configs didn't work in
case where the config was in grandparent.

The generated getters, setters and events now get all the fields
from the originating config.  Previously there was just a static
list of some fields that get copied over.

This solves the problem of @method getting an auto-detected :default
field which doesn't make sense for methods.

Remove the special-case rule of @deprecated tag.

Temporarily patch the Ext.dom.Element#getAttribute method.

To easily insert current data and link to JSDuck homepage.

Fixes: #343

This is to allow third-party packaging of JSDuck without the
inconvenient dependency on therubyracer gem.

Fixes: #339

Check if jsduck.json exists in current working dir, if yes, then
read configuration from it.

Fixes: #335

Inside Ast auto-detection store there :tagname flag.
Inside @param and @type merging store the :params and :type flags.

Create Tag::Autodetected to do the merging of :autodetected fields
from code and docs.