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.

Splitted up the tests into three files.

Changed around the rules of how inheritance works:

- Only inheriting x when item itself doesn't define it.
- No more combining local docs with inherited doc.
- Recursive inheritance now resolves the parent, then inherits from
  it directly, not going to the bottom of inheritance chain and
  inheriting from it.

JSDuck uses the following fields internally, the aren't neccessary
inside export:

- component
- superclasses
- subclasses
- mixedInto
- parentMixins

Also changed Docs app client side to handle the flat members list.
Mostly things got simpler.

As this is a large change, some corners still need to be fixed,
like the --import of JSDuck exports.