Improved syntax tree model and further design

First, the changes.

I try to recontruct my program again. At first, everything in my project
is much better to be moved into a common namespace(module in Ruby).

The basic purpose of rewriting Syntax Tree classes part is just doing
is.

Now the classes have completely rewritten, original it has only two
classes, the CSValue and CSCtrl, both of them inherit from CSTreeNode.
The current version has made a more complex inheritance tree.

All of these part of code are under `CScript::SyntaxTree` module.

Node ............ The basic virtual class, all nodes inherit from this
 |
 `--- Tree ...... A Tree is a root of a program, includes extra infos
 |
 `--- Value ..... Store a single literal value (or a name)
 |
 `--- Control ... virtual class too, for nodes with operands
 |      |
 |      `--- Expression ..... Expressions
 |      |
 |      `--- Statement  ..... Statements, has multiple expressions below
 |      |
 |      `--- Macro .......... Meta instructions for executor
 |
 `--- Container ............. Container, contains a list of nodes

(I found ASCII art is so interesting!)

The reason why I separate original nodes into so subtle different part
is that it is much friendly now to the executor, as it could be much
easier to dynamic dispatch different works to corresponding executors.

At least is is now seems more clear to the programmer right? For
instance, when I adding a new statement in the yacc rule table, I would
get clearly known which type of statement that is, a macro or a
statement. And, obviously parameter list is completely different from a
statement, but formerly they are in the same class.

Further, I added a unprecedented function in the classes, and it would
be a very important behavior in the following developing. It is
`serialization`, not only serialization, but also used as communication
with executor and that part.

I use JSON to do as the medium now. It is chosen because first, it is a
very common used format around the world, second, it can be easily
generated and parsed by so many languages, last, but not least, I just
like this.

I added a function in all Node classes names `as_json`. This function
will covert a node itself into a hash, and further convert into JSON
serialized string.

And I want the commnicate as treenodes between the parser and the
executor to be replaced by just a big hash, or just json is okay.

This is my imagination:

    +--------------+                  +----------------+
    |              |                  |                |
    |  Lexer       |                  |  Executor      |
    |  Parser      |----o  JSON  o----|  Macro Dealer  |
    |  SynatxTree  |                  |  Value Class   |
    |              |                  |                |
    +--------------+                  +----------------+

(ASCII art is addictive!)

Look that, executor is completely get rid of restriction of trees, and
use a common medium to do so.

Rather, I can even have these componments inside:

       +----------------------+
JSON   |                      |      +----------+
  o----| C language converter |----> |C Compiler|
       |                      |      +----------+
       +----------------------+

       +----------------------+
JSON   |                      |      +--------+
  o----|       Optimizer      |----> |Executor|
       |                      |      +--------+
       +----------------------+

And many, many things like that, the only condition is just having a
compatible interface.

Cool isn't it?

To serialize an executable program into static JSON data format, ha! It
seems nobody have done these!

Maybe I imagine things too much, now let return to the practical stuff.

A great job, I suppose, inside the code, in Ruby meta programming, I
used is a mimic method, which act as a module but is actually a method,
which names `Shortcut`, and placed in `CScript::SyntaxTree`, is used for
providing some shortcut to creating the nodes. The method generate a
module with functions defined dynamically. The functions is like the old
`mkVal` and `mkCtrl`, but now it is involved into a method to be
included. The reason why I pay more labor to write mimic method instead of
simply a typical module is that I need a method that can `inject` into
the shortcuts -- I call it `hook`. Now I use this manner to given the
nodes specific location from source in the Parser module.

This version cannot be executed yet, but you can see the construction of
trees is completely all right now.

The method is not completely steady so I haven't do any expert test yet,
so you might meet error in the trees yet now.

Good luck & nice dream!