name mangling again
-------------------

currently we use a very dirty 'name projection' or 'name mangling' hack for
word semantics. it's consise, and straightforward to understand, but quite 
hard to handle since there is no clear distinction of semantics.

i.e. lit, is a host word requiring an argument, but also is visible as lit
int the target mode.

how do we solve this without loosing the straight-line dictionary?
i.e.: i don't like the run-time switching of dictionary priorities, because
it messes up 'mark' and 'empty'.

but there is a way to clearly define semantics of a word, and have the parser
map everything to this clean internal representation.


so, what's the different kinds of words we have:

HOST   ' ' host words
HOST   '_' host macros
TARGET ' ' target words
HOST   ',' target macros
HOST   '#' target interpret words, overriding host words
HOST   '%' macro immediate words, overriding target macros


what about dictionary with dictionary flags, and modes enabling/disabling the flags?


the thing we need is access from each of these things from within the host environment.
can this be done in the same way, but using a better dictionary representation?

i.e.:

: dosomething word, ;

word, either compiles a target macro, or postpones a target word.

: dosomethingelse_ word,_ ;

word,_ postpones a target macro, or double postpones a target word

so
word, means 'target-postpone word'  ( compile target compile semantics )
word_ means 'host-postpone word'    ( compile host compile semantics )
word& means 'tcommand word'         ( compile target execute semantics )

word,_ (no longer legal??)


different mappings:


interpret/compile
(mode state word -> match + interpret action)

define
mode word -> name attribute