`reverse` could infer more from `List*` types with homogeneous elements

Obviously reverse can’t fully compute the output type of a variable-length list with heterogeneous elements. But with a variable-length list of homogeneous elements, the length of the output type can be inferred to be the same as the input type.

In the first two examples below, that use List, reverse correctly preserves the list length in the output type. But with List*, it weakens the type from a two-or-more list to an any-length list.

(define-type ExactlyTwoIntegers (List Integer Integer))
(define exactly-two : ExactlyTwoIntegers '(1 2))
(mb-reverse exactly-two) ; type = ExactlyTwoIntegers

(define-type OneIntOneBool (List Integer Boolean))
(define int-bool : OneIntOneBool '(1 #t))
(mb-reverse int-bool) ; type = (List Boolean Integer)

(define-type AtLeastTwoIntegers (List* Integer Integer (Listof Integer)))
(define at-least-two : AtLeastTwoIntegers '(1 2))
(reverse at-least-two) ; type = (Listof Integer)
;; but it could be (List* Integer Integer (Listof Integer))

The issue names no source file or test entry point. Start by reproducing the three Typed Racket examples and inspect how reverse handles List and List* types; done means a homogeneous List* preserves its minimum length while heterogeneous lists retain their existing behavior.