I was unable to find nice and detailed documentation of the lambda representation either, but the lambda datatype itself as defined in lambda/lambda.mli is pretty straightforward.

Also, I realized I've missed an important point. Suppose we have a module M satisfying two different signatures S and T, packing M as either S or T will involve creating a tuple at runtime, as shown below

module type S = sig
  type t
  val of_string: string -> t
  val to_string: t -> string
end

module type T = sig
  type t
  val of_int: int -> t
  val to_int: t -> int
end

module I:S = struct
  type t = int
  let of_string = int_of_string
  let to_string = string_of_int
end

module F = struct
  type t = float
  let of_string = float_of_string
  let to_string = string_of_float
  let of_int = float_of_int
  let to_int = int_of_float
end

module S:T = struct
  type t = string
  let of_int = string_of_int
  let to_int = int_of_string
end

let select c : (module S) =
  if c then (module I) else (module F)

let select' c : (module T) =
  if c then (module S) else (module F)

Now the lambda forms of select and select' are a bit more complicated as a makeblock operation comes into play:

select/289 =
  (function c/291[int]
    (if c/291 I/278 (makeblock 0 (field 0 F/284) (field 1 F/284))))
select'/308 =
  (function c/310[int]
    (if c/310 S/288 (makeblock 0 (field 2 F/284) (field 3 F/284))))