add named-let support

modified functions:
  * let

now takes:
    (vars . body)
  or
    (name vars . body)

as the good-book says, <<EOF
A recursive procedure defined using letrec can describe loops. Let's
say we want to display a countdown from 10:

(letrec ((countdown (lambda (i)
                      (if (= i 0) 'liftoff
                          (begin
                            (display i)
                            (newline)
                            (countdown (- i 1)))))))
  (countdown 10))
This outputs on the console the numbers 10 down to 1, and returns the
                      result liftoff.

Scheme allows a variant of let called named let to write this kind of
loop more compactly:

(let countdown ((i 10))
  (if (= i 0) 'liftoff
      (begin
        (display i)
        (newline)
        (countdown (- i 1)))))

EOF
(source teach-yourself-a-scheme-in-fixnum-days)
new functions `set-c{a,d}r`, `type-of`, `reverse` and `null?`

new built-in functions:
    * set-car!  [BM]
    * set-car!  [BM]
    * type-of   [BF]
    * reverse   [UF]
    * null?     [UF]
a feature fix for `set-c{a,d}r!`

`set-c{a,d}r!` can be used on not only global variables but also
locals.
intruducing null type as list's end
common value class introducing

A value class could be accessed by a `revo` program with being interpreted as
a data structure that could be used in revo program.

A value class must implement the following method, most of them are
already implemented by default:

    * initialize(*)
      contructor
    * atom?
      whether this object is an atom or a list?
    * list?
      *NO* need to rewrite this function, since it will take the
      opposite value from `atom?`
    * is_true?
      whether is object repesent true or false in a conditional expression
    * inspect
      used in debugging printing
    * to_s
      used for commonly outputing
    * eval(env)
      return itself for literals, and the evaled result for
      evaluatable values