Fix issue with typing application and polymorphic types.

Fixes #7323

When typing application there's a special treatment for polymorphic types, where the arity and kinds of arguments are inferred.
For example: `f => f(~lbl1, ~lbl2)` assigns a polymorphic type `'a` to `f` initially which is then instantated to `(~lbl1:t1, ~lbl2:t2) => t3`.

That same mechanism currently applies when a function is annotated to return a polymorphic type such as `(string, ~wrongLabelName: int=?) => 'a`, where the `'a` is further instantiated to extend the function type with additional arguments.
This mechanism is OK for curried function, but incorrect for uncurried functions: while e.g. `'a => 'b` with curried function designates any function where the first argument is unlabeled, with uncurried function it only designates functions of arity 1.
So when processing application, `'b` should not be expanded further.

Two examples of problematic code that now gives type error:
```res
let r: (string, ~wrongLabelName: int=?) => 'a = (_s, ~wrongLabelName=3) => {
  let _ = wrongLabelName
  assert(false)
}

let tst1 = r("", ~initialValue=2)
let tst2 = r("")(~initialValue=2)
```

and

```res
let f  = (_, ~def=3) => assert(false)

let g1 = f(1,2)
let g2 = f(1)(2)
```

Author: cristianoc

compiler/ml/typecore.ml

@@ -3449,6 +3449,7 @@ and translate_unified_ops (env : Env.t) (funct : Typedtree.expression)
 
 and type_application ?type_clash_context total_app env funct (sargs : sargs) :
     targs * Types.type_expr * bool =
+  (* Printf.eprintf "type_application: #args:%d\n" (List.length sargs); *)
   let result_type omitted ty_fun =
     List.fold_left
       (fun ty_fun (l, ty, lv) -> newty2 lv (Tarrow (l, ty, ty_fun, Cok, None)))
@@ -3465,6 +3466,7 @@ and type_application ?type_clash_context total_app env funct (sargs : sargs) :
     | Tvar _ when total_app -> true
     | _ -> false
   in
+  (* Printf.eprintf "force_tvar:%b\n" force_tvar; *)
   let has_arity funct =
     let t = funct.exp_type in
     if force_tvar then Some (List.length sargs)
@@ -3550,11 +3552,15 @@ and type_application ?type_clash_context total_app env funct (sargs : sargs) :
       type_unknown_args max_arity ~args ~top_arity:None omitted ty_fun []
     | (l1, sarg1) :: sargl ->
       let l1 = to_noloc l1 in
+      (* let lbl_name = label_name l1 in
+      Printf.eprintf "  type_unknown_args: lbl_name:%s\n" lbl_name; *)
       let ty1, ty2 =
         let ty_fun = expand_head env ty_fun in
         let arity_ok = List.length args < max_arity in
         match ty_fun.desc with
-        | Tvar _ ->
+        | Tvar _ when (* l1 = Nolabel || *) force_tvar ->
+          (* This is a total application when the toplevel type is a polymorphic variable,
+          so the function type including arity can be inferred. *)
           let t1 = newvar () and t2 = newvar () in
           if ty_fun.level >= t1.level && not_identity funct.exp_desc then
             Location.prerr_warning sarg1.pexp_loc Warnings.Unused_argument;
@@ -3605,9 +3611,11 @@ and type_application ?type_clash_context total_app env funct (sargs : sargs) :
       when sargs <> [] && commu_repr com = Cok && List.length args < max_arity
       ->
       let name = label_name l and optional = is_optional l in
+      (* Printf.eprintf "  type_args: name:%s, optional:%b\n" name optional; *)
       let sargs, omitted, arg =
         match extract_label name sargs with
         | None ->
+          (* Printf.eprintf "  extract_label: None\n"; *)
           if optional && (total_app || label_assoc Nolabel sargs) then (
             ignored := (l, ty, lv) :: !ignored;
             ( sargs,
@@ -3640,8 +3648,14 @@ and type_application ?type_clash_context total_app env funct (sargs : sargs) :
         sargs (* This is the hot path for non-labeled function*)
   in
   if total_app then force_uncurried_type funct;
+  (* Printf.eprintf "total_app:%b\n" total_app; *)
   let max_arity = get_max_arity funct in
+  (* Printf.eprintf "max_arity:%d\n" max_arity; *)
   let top_arity = if total_app then Some max_arity else None in
+  (* Printf.eprintf "top_arity:%s\n"
+    (match top_arity with
+    | Some _ -> "Some"
+    | None -> "None"); *)
   match sargs with
   (* Special case for ignore: avoid discarding warning *)
   | [(Nolabel, sarg)] when is_ignore ~env ~arity:top_arity funct ->