Trampolining is one way to implement "tail call optimisation". This basically means that when the last instruction (the "tail") of a function is a call to another function (possibly the same one, recursively), then we can perform an optimisation: rather than "going down" into the function (adding a new stack frame) we can run it where we already are (in our current stack frame). This optimisation is possible because we know that we don't need our current stack frame anymore, since this is the last instruction.

Ever find yourself writing a "main loop" full of unrelated code which only appears in the same place because you're forced to keep it all between the loop's braces? That's a prime candidate for mutual recursion, made safe using tail-call optimisation:

  var foo = function() {
    //
  };
  var bar = function() {
    //
  };
  var baz = function() {
    //
  };
  var main = function() {
    while (true) {
      foo();
      bar();
      baz();
    }
  };
  main();

Can be replaced with:

  var foo = function() {
    //
    bar();
  };

  var bar = function() {
    //
    baz();
  };

  var baz = function() {
    //
    foo();
  };
  foo();

This is how I tend to write Javascript; although I generally handle tail-call optimisation by using setTimeout(foo, 0), which has the same effect.

Not the same effect. setTimeout() will execute the callback after the main event loop has completed, potentially allowing the browser to reflow the page, etc. Doing that will slow things down considerably with lots of callbacks.

You handle TCO by making it asynchronous? WTF.