Temporaries, references, lifetimes and const_cast

I know this subject comes up a lot - and I've got the gist of it - but
there is one particular case that I can't work through. Is it legal or not?

This has come up before:

<code>
std::string Func() { return "monkey"; }

int main()
{
    const std::string &cstr = Func();

    std::string &str = const_cast<std::string &>(cstr);

    str = "ape";
}
</code>

and the Jury seems to be out still.
But I want to do something even nastier:

<code>
#include <string>
#include <iostream>

std::string Func() { return "monkey"; }

std::string& Funky(std::string& str){
    return str += " magic";
}

std::string& Munky(const std::string& cstr){
    return const_cast<std::string &>(cstr);
}

int main(){
    //Funky(Func()); <-- no-no!
    std::cout << Funky(Munky(Func())) << std::endl;
}

</code>

I haven't had trouble compiling it, but why hasn't the constant
reference bound to the return from Func() gone out of scope when Munky()
returns?

pt.

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]