So the act of a tail-call optimization is freeing up the unneeded local variables because they've been passed on?

If you're saying that it's because they've been passed to another function, then no. The memory space is being freed up because there is literally zero chance those variables will be used again. Think of this very simple pseudocode:

 function myFunction() {
    int x = 0;
    x++;
    return myOtherFunction();
 }

In this code, we're creating a variable called x which is scoped locally to myFunction, meaning that that variable is meaningless after myFunction finishes executing. Once you hit the return statement at the end of the function, the following happens:

• myOtherFunction is run
• myOtherFunction ends and returns a value
• myFunction ends and returns the value passed to it by myOtherFunction.

Nothing happens, local to myFunction, between the call to myOtherFunction and myFunction returning a value. Because of that, everything associated with myFunction (save for the return) is unneeded and can be removed from memory.

In fact, since all the return statement is doing is passing along another returned variable, then you could say that myOtherFunction is directly returning a variable to whatever called myFunction, which means that we don't even need to return a value to myFunction, and can opt instead to return it directly to the function which called myFunction, bypassing myFunction completely and making the entire function eligible to be swept from memory.

With recursive functions, and tail-call recursion, it's even easier. Because the calling function and the called function are the same, with a tail call you can run the called function in the exact same place in memory as the calling function. In other words, rather than allocating a new chunk of memory for the new function, the existing calling function is just reinitialized using the arguments in the call in the return statement. This has exactly the same effect as calling a new copy of that function, but uses no extra space in memory.

It's funny because I've never thought that the local variables created in a function could possibly still exist in memory.

All variables are kept in memory. Where did you think they were kept?