Well, I've run out of month, if not out of languages. I guess I failed at my goal; still, the exercise was definitely worth doing. I'm definitely going to finish the one I'm currently working on, in C. Doing it continuation-machine style in C was probably a mistake in terms of complexity -- I suspect it's a good order of magnitude worse than any of the previous ones.
At this point I have the general structure complete -- I have a 'step' function that takes a (continuation, expression, environment) tuple, and produces another one of same. My continuations are structured as chains (stacks) of frames, with each frame being specialized to a particular in-progress operation -- either an application or one of the special forms (progn, cond, etc.)
The state tuples and continuation frames are mutable, and I should probably be manually memory-managing them but I'm currently just letting them become garbage. The s-expression structures are immutable (that is, I never mutate them), and are meant to be GC'ed. (When a continuation is captured or thrown to, I deep-copy it; a continuation embedded inside a sexp is immutable and gc-able.)
Since I'm off the clock now, I think I'll go ahead and finish it with a parser and a simple garbage collector.
After that I may continue to do some of the other languages I didn't get to; we'll see. There are definitely a few left I'd like to do.