Revert adding in-pairs to racket/sequence.

`in-dict` is more general, and `for` loops optimize it already.

pkgs/racket-doc/scribblings/reference/sequences.scrbl

@@ -794,18 +794,6 @@ If @racket[min-count] is a number, the stream is required to have at least that
 
 @history[#:added "6.2.900.6"]}
 
-@defproc[(in-pairs [seq sequence?]) sequence?]{
-  Produces a 2-valued sequence whose pairs of elements are the successive
-  @racket[car]s and @racket[cdr]s of the elements of @racket[seq].
-  Equivalent to
-  @racket[(in-parallel (sequence-lift car seq) (sequence-lift cdr seq))].
-
-  @examples[#:eval sequence-evaluator
-  (for/list ([(a b) (in-pairs '((1 . a) (2 . b) (3 . c)))]) b)
-  ]
-  @history[#:added "6.2.900.6"]
-}
-
 @defproc[(in-slice [length exact-positive-integer?] [seq sequence?])
          sequence?]{
   Returns a sequence whose elements are lists with the first @racket[length]

pkgs/racket-test-core/tests/racket/sequence.rktl

@@ -268,16 +268,6 @@
 ;; ----------------------------------------
 ;; Additional sequence constructors
 
-(test #t sequence? (in-pairs '()))
-(test #t sequence? (in-pairs '((1 . 2) (3 . 4))))
-(test '()
-      values
-      (for/list ([(x y) (in-pairs '())])
-        x))
-(test '(2 4 6)
-      values
-      (for/list ([(x y) (in-pairs '((1 . 1) (2 . 2) (3 . 3)))])
-        (+ x y)))
 (test #t sequence? (in-slice 1 '()))
 (test '() values (for/list ([v (in-slice 1 '())]) v))
 (test '((0 1)) values (for/list ([v (in-slice 3 (in-range 2))]) v))

racket/collects/racket/sequence.rkt

@@ -23,7 +23,6 @@
          sequence-count
          sequence/c
          in-syntax
-         in-pairs
          (contract-out [in-slice (exact-positive-integer? sequence? . -> . any)]))
 
 (define empty-sequence
@@ -259,17 +258,6 @@
   (or (stx->list stx)
       (raise-type-error 'in-syntax "stx-list" stx)))
 
-(define (in-pairs seq)
-  (make-do-sequence
-   (λ ()
-     (let-values ([(more? gen) (sequence-generate seq)])
-       (values (λ (e) (let ([e (gen)]) (values (car e) (cdr e))))
-               (λ (_) #t)
-               #t
-               (λ (_) (more?))
-               (λ _ #t)
-               (λ _ #t))))))
-
 (define (in-slice k seq)
   (make-do-sequence
    (λ ()