Is there a way to make F# keep the type of a parameter generic?

This cannot be done in F# with just ordinary functions. The issue is that in F#, you cannot pass a generic function as an argument to another function. When F# prints the type of your testFunc, you get:

('a list -> 'a list option) -> unit

The key thing here is that 'a is a type variable that is fixed when you invoke the function. Formally, there is a universal quantification over the whole type, i.e.:

forall 'a . (('a list -> 'a list option) -> unit)

This means that when you call testFunc, you first set 'a to one specific type. What you need here (and what F# does not support) is to have the quantification only for the type of the argument:

(forall 'a . ('a list -> 'a list option)) -> unit

If you could do this, then the body of the function could, itself, be able to set 'a to two different types when it accesses the function. This cannot be done in F# with plain functions, but you can encode this using an interface:

type GroupTest =
  abstract Invoke<'T> : 'T list -> 'T list option

This interface has a generic method, i.e. essentially a function of type (forall 'a . ('a list -> 'a list option)). You can then write testFunc as a function of GroupTest -> unit:

let testFunc (groupTest:GroupTest) =
  [ [1; 2] ]
  |> List.choose groupTest.Invoke
  |> List.map (fun l -> l |> List.map (fun i -> "a"))
  |> List.choose groupTest.Invoke
  |> printfn "%A"

testFunc { new GroupTest with member x.Invoke a = pairTest a }

The syntax for this is a bit clumsy, so I would only use this trick if it was something essential about my domain. If you need this just in one place, you're probably better off with a simple trick like duplicating the argument (or maybe duplicating the whole testFunc function for each different groupTest). But the interface trick works and it's a general way to do what you're asking about.

let testFunc groupTest1 groupTest2 =
  [ [1; 2] ]
  |> List.choose groupTest1
  |> List.map (fun l -> l |> List.map (fun i -> "a"))
  |> List.choose groupTest2
  |> printfn "%A"

testFunc pairTest pairTest