On reflection, that sounds similar to just in time (JIT) compiling for those languages/VMs/interpreters that support it. Java, which I do know, does something similar from bytecode to native code. You compile source text, your .java files, completely to Java byte code. This is what the resulting .class files contain. However, once you invoke a Java program, the bytecode is not continually re-interpreted every time. Since the introduction of JIT compilation as part of the JVMs capabilities, bytecode gets compiled as it is loaded then each time those same classes and methods are invoked, the JVM is using native code. With HotSpot, that is admittedly an oversimplification, but I think the parallel holds.
What you described sounds like a JIT parse, that Perl generates parse trees or something byte-code like–the code structures you mentioned–once per execution. Would it be fair to say that the difference in Perl 6 will be more a matter of degreed, then? That either the explicit compile or the in-line JIT compile will be all the way to native code, rather than something closer to a parse or compile to just byte code?
I rather suspect the strategy of caching parse and compile results in interpreted or partially interpreted languages is pretty common and with modern CPU speeds and memory capacities I am sure it is relatively cost effective.