text: Title: Argument conversion should be attempted with all possible types even if some type wouldn't be recognized
  Body: If we have a keyword like
  ```
  def kw(arg: Union[T, int]):
      ...
  ```
  and the type `T` isn't recognized (i.e. doesn't have a converter), the used argument is returned as-is without attempting conversion with remaining types. For example, if we'd use
  ```
  Kw    42
  ```
  the argument value passed to the keyword would be a string and not an integer.
  
  This is pretty strange and inconsistent. It would be better to try conversion with all argument types in the order they are specified. If a type has a converter and conversion succeeds, the converted value should be returned.
  
  It's a somewhat separate question to decide what to do if conversion doesn't succeed with any converter and there are some unrecognized types. Because we pass values without conversion when using only an unrecognized type like `arg: T`, I believe we should do that also with unions. That way this change would also be mostly backwards incompatible. We can revisit this decision later.
  
  This change would be backwards incompatible simply because the argument passed to the keyword in the above example would change. I consider that fine even in a non-major release because the current behavior is, in my opinion, buggy. It's also pretty unlikely tat unrecognized types are used with recognized types like this so there shouldn't be many/any who are actually affected.