Re-dev is done, compromise\?? -> backtrack, alternation BT works.

The BT in the title means Backtrack, that is the meaning of what
old `compromise` method is for. '回溯' obviously is better than '妥協'
isn't that.

Not only changed a name, but the definition of the method, the old one
is a couple of methods, `compromise?` and `compromise`. And I found
they are partially overlapped, so this time I also merged it up, into
the sole `backtrack`. Which do backtrack if possible, otherwise, it
return a `false` value to indicate there's no possibility to
backtrack.

Due to this change, many methods are actually simplified, so maybe the
code impact will decrease, too. And this change would involve many files.

I'd like to do such (reconstruction|optimization|simplification), and
the result is appreciatable, anyway.

It is late that I gotta go to bed as soon, yet I still have a diary to
write. Better be quickly :)
simply: large changes

First, interfaces changed. Thus you now could regard a regular
expression object as Sreg object, just as what it should be. (at
before you could only access a raw regexp tree)

All interface changes are for enclosing other things.

Now a regular expressions could be presented as a 3 element tuple:

* regular expression tree
* reference table
* match result

Those three parts work together, then a regexp object is formed.

Here's a detailed procedure how a regular expression object works

First, the reference table is initialized, and now it is empty.

Then a regexp tree is constructed from the parser, inside the
construction, some nodes (group) will create index for itself in the
reference table. (Of course, nodes' optimization was done here.)

And now the reference table should be filled, providing reference
from numeric id in a regular expression node object.

Then the original object is constructed, the next step is matching.

The matching part was described much before, you should know already
each node will produce a match position and a length mark that are
store in itself. Good.

After matching, the engine will traverse the reference table, and
point out every indexed object, fetch its position and length and save
in the match result. match result uses MatchData class, it provides
similiar functions as MatchData in ruby core does. You can now refer
it by many relevant methods for various later process.

Totally, the engine will keep these principles:
* Optimization is optional always, the result before and after
  optimization will not be different.
* (I don't remember want I wanted to say :( )

Though the first used to lead a crisis.

Anyway, it is very late now. I got to quickly finish this log and my
diary, then, find love in my sweet dream world.
Interfaces optimization

including:
  - MatchData class(internal interface)
    - `MatchData.build` instead of `_alloc.set_match`
    - all fields are now in full name
  - Sreg Implement
    - option of Sreg object to disable optimization: `O0`
modified test_match
Merge branch 'dev' into test
Small changes and passes the tests

Inteface change:
  - MatchData class now have method `length` and `pos` redirects
    to `@match_length` and `@match_begin`

On test program:
  - Adapt the old test cases to the the new interface.