Simplify wrapping then destructuring

[jfmengels]

x |> Constructor |> (\(Constructor y) -> ...)
-->
x |> (\y -> ...)

Constructor >> (\(Constructor y) -> ...)
--> (\y -> ...)

(originally from #444 (review))

Similarily, there are other wrappers that we can simplify away:

-- If Constructor is just a single `FunctionOrValue` type constructor
-- then it HAS to be of shape `type alias Constructor = { y : ... }`
Constructor >> (\{y} -> ...)
--> (\y -> ...)

Tuple.pair x >> (\( _, y ) -> ...)
--> (\( y ) -> ...)

-- Same for first, second or third ignored tuple element
( x, y ) |> (\( a, _ ) -> ...)
--> x |> (\( a ) -> ...)

[jfmengels]

If the constructor has multiple parameters but that are ignored, and then one we match on is the one we care about, then we could also do it.

Constructor a b >> (\(Constructor _ _ y) -> ...)
--> (\y -> ...)

Same for record type aliases, though we have to remember the name of the last field.

type alias Constructor =
  { firstField : Int
  , lastField : Int
  }

Constructor a >> (\{y} -> ...)
--> (\y -> ...)

But if the last field is ignored (or if some fields are ignored), then we can remove the pipeline/composition.

type alias Constructor =
  { firstField : Int
  , unused : Int
  , used : Int
  , lastField : Int
  }

Constructor a b c >> (\(Constructor {firstField, used}) -> ...)
-->
Constructor a b c >> -- This line will be removed by other simplifications
(\_ ->
  let firstField = a
      used = c
  in
  ...
)

Note: If there is an alias to the constructor argument (\((Constructor {x}) as a) ->, then we should not do this simplification.