Because almost all queries need to exclude the deleted comments,
it helps having a view that excludes these.

Instead of two fields 'ext-js' and '4' we can have just 'ext-js-4'.
Simplifies most queries.

Gives much cleaner look to our methods list.  This is also the way how
other JavaScript documentation tools display the method signature.

Ignore statements that don't contain a `return` statement.

This means that now a function that contains just one `return this;` at
the end of itself will be detected as chainable; given there's no other
return statements anywhere in the function body.

Forgot to excercise this code when refactoring the :members structure.

No more simply labeling constructors with "Object" return type -
instead the ReturnValues class assigns the actual class as return type.

Planning to extend its functionality to auto-generation of other return
values too.

As we're only detecting 'return this;' using a predicate is better
than a function returning 'this' or nil.

FunctionAst is now also a singleton, but that fact is hidden away behind
static #chainable? method.

To auto-detect return types of functions from source code.

This version is able to auto-detect if a simple function without any
control flow statements returns this.

When doc-comment contains @return {OwnerClass} this,
automatically add @chainable tag too.

Encapsulate both full metadata rendering and signature rendering inside
it.

Showing the text:

    New since {version}

This is quite a hack, but was really needed. Damn!

A leftover from refactoring.

Easier to just use cls[:name] and keeps JsDuck::Class simpler.

Turns out the short class name is only needed when generating search
data - so no need for the short_name method to be in JsDuck::Class.

Not really a responsibility of the core JsDuck::Class.

The hash is no more needed, we only need to loop through all the types.

We don't care about static members inherited from parents and mixins -
they could be completely valid in those other classes - it's the
concrete singleton who's statics interest us.

Allowing to filter out just local (non-inherited) members.

Remove new_* prefixes from map-generator methods.

The #to_json wasn't used at all.

The #to_hash was only used by FullExporter where it could be replaced by
doing the cloning right in there.

Discard JsDuck::Class methods:

- members
- constructor_first
- members_hash
- local_members_hash
- get_members
- all_members
- reset_members_lookup!

The new #find_members replaces most of them.

Moved sorting and ordering of constructor into FullExporter,
so the #constructor_first method still exists, but is elsewhere.
Also added tests for exporter, but the export format still
remains the same.

The code for warning about statics in singleton moved to Lint.

Related to this there's one change in behavior - static members
in singleton are no more cursed into instance members.  That's
because a singleton actually can contain static members, though
it's silly and JSDuck warns about that, but you can even access
those static members in a clumsy way:

    MySingleton.statics().staticMethod();

This is where statics: {} end up when you define them in Ext 4 way
inside a singleton class.  And I've seen some classes in Ext/Touch
codebase even doing so... it's nevertheless silly.

As for the bogus @static tag use in singleton classes for members
that aren't really static - these just need to be fixed.

Like with old #get_members the :static option can be true, false or nil.
With :static=>false only non-static members are returned.

To go along with #find_members.