Add namespaces stack!

Take for example this grammar:

    %token   foo1      a    -> ns1
    %token   foo2      x    -> ns2
    %token   end       e

    %token   ns1:bar   b
    %token   ns1:baz   c    -> ns3
    %token   ns1:tada  t    -> __shift__

    %token   ns2:bar   y
    %token   ns2:baz   z    -> ns3
    %token   ns2:tada  T    -> __shift__

    %token   ns3:qux   =   -> __shift__

    #test:
        ( <foo1> | <foo2> ) <bar> <baz> <qux> <tada> <end>

It recognizes two data:

    1. abc=te
    2. xyz=Te

The `ns3:qux` token can be reached by two namespaces: `ns1` and `ns2`.
Thus, the `__shift__` keyword will go back to the previous namespace.

We can use the `__shift__ * n` syntax, where `n` is a non-negative
integer, e.g.: `__shift__ * 3` will go back to 3rd previous namespace.

Data 1 will produce the following token sequence:

     #  namespace   token name   token value   offset
    --------------------------------------------------
     0  default     foo1         a                  0
     1  ns1         bar          b                  1
     2  ns1         baz          c                  2
     3  ns3         qux          =                  3
     4  ns1         tada         t                  4
     5  default     end          e                  5
     6  default     EOF          EOF                6

Data 2 will produce the following token sequence:

     #  namespace   token name   token value   offset
    --------------------------------------------------
     0  default     foo2         x                  0
     1  ns2         bar          y                  1
     2  ns2         baz          z                  2
     3  ns3         qux          =                  3
     4  ns2         tada         T                  4
     5  default     end          e                  5
     6  default     EOF          EOF                6
Update lexing performance when having lot of ns.
Avoid stacking namespaces if not necessary.

If there is no `__shift__` keyword, we do not stack namespaces. This
avoids to compute a giant stack that will never be reduced.