Implementations of unzip in Racket
Doing it with folds pretty much begs you to create a custom accumulator and recursive function or fold within a fold like that. 

A couple notes. I don't think foldr is tail-recursive. Also (λ (x acc) (cons* x acc)) is redundant. You can just use cons*

You're also using (reverse lst) in a few different places. You could create a separate definition here, or refactor. 

(define (unzip lst)
  (define (template lst) ;;a list of null lists 
    (if (null? lst)      ;;of the proper length
        '()
        (foldl (λ (x acc) (cons '() acc)) '() (car lst))))
  (define (cons* heads tails)
    (reverse (foldl (λ (hd tl acc) 
                       (cons (cons hd tl) acc)) 
                    '() heads tails)))
  (reverse 
      (foldl cons* template lst)))


Not much chage, but perhaps a bit easier to see what's going on. If your wanting to do it with a single fold, thats a bit tricker.

(define (unzip L)
 (define (mangle glob) 
   (let loop ((news '()) (acc glob))
      (if (or (null? (car acc)) (pair? (car acc))) 
          (cons (reverse news) (car acc))
          (loop (cons (car acc) news) (cdr acc)))))
  (reverse (apply foldl (lambda z (mangle z))'() L)))


Notice the lambda is just grabbing a list off all arguments, and we are applying foldl to the lists of lists, as if we are folding multiple lists. However arity is unknown so I've got to take all the arguments as a list, and figure out what is new and what was the accumulator on each round. As is this will choke on a list of lists of lists, but maybe an interesting approach.