It’s because the type-checker goes to work *after* the arguments have been matched up to parameters. The matching of arguments-to-parameters happens purely textually, because the types involved have not been checked yet, so the arguments are assigned greedily to the first parameter where the label matches.
Essentially, the compiler finds all possible candidate functions by name (ideally this should be by compound-name, but I’m not certain that is the case yet). Then it attempts to greedily match call-site arguments to declaration-site parameters.
After the arguments have been matched up with parameters, the type-checker does its thing to figure out overload resolution and literal types and so forth.
But in your second example it never even gets that far, because the attempt at matching arguments to parameters failed:
There was only one candidate function, and it has two unlabeled parameters. The first unlabeled argument at the call-site was matched to the first unlabeled parameter of the function, and there was no subsequent argument available to match with the second parameter.
There does exist an algorithm which can match arguments to parameters non-greedily, properly accounting for default-values, but it runs in O(n²) time (where n is either the number of arguments or parameters, I can’t recall which—maybe it’s O(m*n)?).