Redefine named `let` so as to have the same checks as define'd functions

[Metaxal]

Also maybe accept keywords:

For example:

(let loop (#:? [iter 1] #:? [acc '()] #:? [left '()] #:? [right l])
  (cond
    [(empty? right)
     (reverse acc)]
    [(eq? x 'restart)
     (loop #:iter (+ iter 1)
           #:acc acc
           #:left '()
           #:right (append (reverse left) (rest right)))]
    [else
     (define x (first right))
     (loop #:iter (+ iter 1)
           #:acc (cons (list iter x) acc)
           #:left (cons x left)
           #:right (rest right))]))

That's a lot more readable when there are many arguments.

[Metaxal]

Note that named lets can be expanded (or redefined) using letrec. For example reverse is implemented as

(letrec-values ([(loop)
                       (lambda (a l)
                         (if (null? l)
                             a
                             (loop (cons (car l) a) (cdr l))))])
                     (loop null l))

So we can just parse the header of the named let as for lambda, but allowing only optional arguments.