Add small on the fly parser compiler

This patch adds the new property `nesting`, which can contain an
array of possible start and end characters, matched by the pattern.
During execution the array is compiled into a small efficient parser,
which prevents any other pattern between the start and end characters.

By default the start and end characters are the same, the escape
character is `\` and multiline is assumed to be `true`. But it is
possible to modify the default values by using an object literal instead
of a string. The following example should illustrate how it works:

The generated parsers are designed to be efficiently JIT-compilable
into assembler instructions.

'string': {
    pattern: /("|')(\\?.)*?\1/g,
    nesting: ['"', '\'']
},

'regex': {
    pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,
    lookbehind: true,
    nesting: { start: '/', multiline: false }
}

The generated parser for the above code snipped looks like this:

function(match, lastIndex) {
var in34 = !!this.in34;
var in39 = !!this.in39;
var in47 = !!this.in47;
var i = lastIndex || 0,
    str = match.input,
    len = match.index,
    last = this.last || 0,
    c = last;
for (; i < len; ++i) {
    last = c;
    c = str.charCodeAt(i);
    switch (c) {
        case 34:
            in34 = (!in34 || last === 92) && !in39 && !in47;
            break;
        case 39:
            in39 = !in34 && (!in39 || last === 92) && !in47;
            break;
        case 47:
            in47 = !in34 && !in39 && (!in47 || last === 92);
            break;
        case 10:
            in47 = false;
            break;
    }
};
this.in34 = in34;
this.in39 = in39;
this.in47 = in47;
this.last = last;
return !in34 && !in39 && !in47;
}