Both get inherited from BooleanTag.

In so doing we need to also copy over the :protected property when
doing inheriting and expansion of accessors.

Builtins::Tag now supports the @signature attribute like MetaTag.
For now the signature logic is duplicated as both tag groups support it.

In search data and class data export the data for builtin tags is
added to :meta field, so the frontend logic can stay the same.

On the good side, @private no more needs to be duplicated in both
member[:private] and member[:meta][:private] - just the former will do.

No more assume everything's coming from doc - also look at the
code data and merge stuff from there that didn't came from doc.

Make use of this to implement @evented and @accessor as BooleanTag
subclasses.

Use it as a base for @hide and @inheritable.

Tags can now define #key attribute and #process_doc method - the
latter will take care of combining the results of #parse.

Detection of @hide and @inheritable is now entirely done in
corresponding Tag classes.

After messing a lot with trying to move AstNode object creation
straight to JsParser class, I discovered that it might not be the best idea.

Most of these have now been moved inside AstNode class.
Including the Serializer and Evaluator.

Also introduce AstNodeArray#map.

Making use of AstNodeArray class.

AstNode's must now be created with AstNode.create method, which
will decide whether to create AstNode or AstNodeArray.

Use AstNode class.

Builtin tags can now define @ext_define_pattern - which causes
the #parse_ext_define method to be invoked when such an item is
encountered within Ext.define config.

Instead of using the raw AST node values.

For start for the simpler things like extend, singleton, mixins, uses, ...

Allows iterating over object expression properties.
Also using it in Ast#detect_ext_define.

This eliminates much of the ext_* methods from Ast class.

Eliminating some Ast class methods that are now taken care of by AstNode class.

This way it doesn't have to be initialized every time Ast class
is invoked. Also one less options object to be passed around.

The purpose of the base class is to clearly separate out methods that
can be called from @tag implementations.

All builtin tags are now implemented as tag classes.