Transducers do not use the `#:finisher` function

[samdphillips]

The following program should produce an error when run.

#lang racket/base

(require rebellion/base/variant
         rebellion/collection/list
         rebellion/streaming/transducer)

(define (chunking n)
  (make-transducer #:starter
                   (lambda ()
                     (variant #:consume null))                              

                   #:consumer
                   (lambda (state v)
                     (let ([state (cons v state)])
                       (cond
                         [(= n (length state)) (variant #:emit state)]
                         [else (variant #:consume state)])))
                   
                   #:emitter
                   (lambda (state)
                     (emission (variant #:consume null)
                               (reverse state)))
                   
                   #:half-closed-emitter
                   (lambda (state)
                     (half-closed-emission (variant #:finish #f)
                                           (reverse state)))
                   
                   #:half-closer
                   (lambda (state)
                     (if (null? state)
                         (variant #:finish #f)
                         (variant #:half-closed-emit state)))

                   #:finisher
                   (lambda xs (error 'finisher "~s" xs))))

(transduce (in-range 20)
           (chunking 3)
           #:into
           into-list)