Lambda expressions and closures support!

Lambda, is the most beautiful part of functional programming.

I like it very much so this time, I added this function as hurry as I
can.

Basically, in this version, lambda could be generate with operator
`->', in form of:

    -> { |p1, p2| body; }

where `p1` and `p2` is parameters and the `body` is just the body.

I considered to change it into the form:

    -> (p1, p2){ body; }

But now it is pending.

Lambda, is a code block like function, with undecided parameters, and
is callable.

Unlike function definition, a lambda in cscript is a expression rather
than a statement, that means, you can use this trick to merge multiple
statements into a sole expression.

Another point from a function is, a lambda has its own binding from
where it is first defined. The binding's conception is just like in
Ruby:

Binding in cscript is implemented as a hash table with variable
name/variable value mapped. And once a lambda is evaluated(called), it
will first seek the unknown variables from the binding. And if not
found, it will then just find upward. However, a function does just
report an error that the variable is not found actually.

For this feature, closure is being possible now.

Read the code below(from the unittest):

    def add(x) {
        return -> { |y|
            x + y;
        }
    }

The function `add` will return a lambda expression that dynamic
generated with known binding that designated `x` is inside. So once you
may call:

    add5 = add(5);

Which will create a lambda object, with binding that `x` => 5.

Then if you execute the lambda with a value, like:

    add5(3);

It will first pass the `3` as argument `y` to the lambda, and when it
can't found the value of name `x`, it will look up its binding, and then
got a `5`.

Cool isn't it? Actually each lambda object has its isolated binding,
that means you can't use code as following and regardless the pollution
between them:

    add3 = add(3);
    add5 = add(5);
    add3(add5(2)); /* expectedly get a 10 */

Awesome!

For this feature, I changed some existing code, these are the detailed
stuff:

Changes:
    * `ReturnSignal` class can carry a value now.
    * `CallStack` class do not reserve an temprary return value for
      implement returnning as the above trick does it better.
    * New `set_variables` for `RunStack` and `SymbolTable`, to store a
      hash of name-value pairs into the symbol table.
    * `FUNC_CALL` now consider about both function calls and lambda
      calls.
    * The calling work is no longer dealed inside executor, rather, the
      callable object does it now.
    * `return` operation is now not only for `Function`(`CallStack`),
      lambdas accept this too. Now the return is implemented as a
      general function inside `RunStack`, which use different return
      manner for different type of calls.
    * `RunStack` deletes the function `store_global` now, use
      `stack.symbol_table.store_global` instead.
    * New stack type determiners in `RunStack`:
        * `is_lambda_call?`
        * `is_func_call?`
        * `is_inside_loop?`  -- This is not used yet.
    * New `make_binding` method inside `RunStack`, which does generate a
      hash table of current binding.
    * `set_variables` in SymbolTable do store new variables, and the
      `variables` method yet do return its local symbol table, without
      duplication. (be careful to change it)
    * `callable?`, `is_lambda?` determiner in `Value` class
    * other small additional stuff in the `Value` class

Note that the third unittest `test_9_mulcall.rb` is not passed yet.

Oh my paganini!