effect syntax: effect patterns as computation patterns

[Octachron]

This PR is meant to be read at the top of the effect-syntax PR(#12309). In particular, only the last commit is new.

This commit aims at making the typechecker part of the effect syntax changes smaller.
This is done by merging back effect patterns into the computation pattern umbrella in the typechecker part of the compiler. Splitting patterns by kind is then done when compiling to the lambda IR.

This change also has the advantage of making the error messages for non-toplevel computation patterns more uniform:

let f [effect _, _] = ()

Error: Effect patterns are not allowed in this position.

let g [exception _ ] = ()

Error: Exception patterns are not allowed in this position.

Incidentally, it makes the compiler support cases containing mixed effect, exception and value cases:

let catch f = match f () with _  | exception _ | effect _, _ -> ( )
type _ Effect.t += A: unit Effect.t
type _ Effect.t += B: unit Effect.t

let () = catch ignore; catch (fun () -> raise Not_found); catch (fun () -> Effect.perform A)

However, the feature is mostly useless, since effect types require type equations to be useful, and we discard type equations introduced under or-patterns. In other words, it is impossible to bind the continuation in the pattern above:

let test f = match f () with k | effect A, k -> ()

Error: The variable k on the left-hand side of this or-pattern has type 'a
      but on the right-hand side it has type (%eff, 'b) continuation
      The type constructor %eff would escape its scope