<!--- Verify first that your issue is not already reported on GitHub -->
<!--- Also test if the latest release and devel branch are affected too -->
<!--- Complete *all* sections as described, this form is processed automatically -->

##### SUMMARY

Since https://github.com/ansible/ansible/pull/57145, `elements=str` in Arguments_spec raises an error. We need to use elements="str" instead. I've done a workaround for VMware ( ansible-collections/vmware#235 ), but we may see more cases like that in the future. Is this an expected behaviour?

```python
        associable_object_types=dict(
            type='list',
             elements=str,
        ),
```

The error:


```
The full traceback is:
  File "/tmp/ansible_vmware_category_payload_w4g0m32x/ansible_vmware_category_payload.zip/ansible/module_utils/basic.py", line 1775, in _handle_elements
    validated_params.append(type_checker(value, **kwargs))
fatal: [testhost]: FAILED! => {
    "changed": false,
    "invocation": {
        "module_args": {
            "associable_object_types": [
                "Folder"
            ],
            "category_cardinality": "multiple",
            "category_description": "Folder",
            "category_name": "Folder",
            "hostname": "vcenter.test",
            "password": "VALUE_SPECIFIED_IN_NO_LOG_PARAMETER",
            "port": 443,
            "protocol": "https",
            "state": "present",
            "username": "administrator@vsphere.local",
            "validate_certs": false
        }
    },
    "msg": "Elements value for option associable_object_types is of type <class 'str'> and we were unable to convert to str: 'param' is an invalid keyword argument for str()"
}

```

##### ISSUE TYPE
- Bug Report

##### COMPONENT NAME

lib/ansible/module_utils/basic.py

##### ANSIBLE VERSION
<!--- Paste verbatim output from "ansible --version" between quotes -->
```paste below
devel
```
else:
                    elements = params[k]
                for idx, param in enumerate(elements):
                    if not isinstance(param, dict):
                        self.fail_json(msg="value of %s must be of type dict or list of dict" % k)
                    new_prefix = prefix + k
                    if wanted == 'list':
                        new_prefix += '[%d]' % idx
                    new_prefix += '.'
                    self._set_fallbacks(spec, param)
                    options_aliases = self._handle_aliases(spec, param, option_prefix=new_prefix)
                    options_legal_inputs = list(spec.keys()) + list(options_aliases.keys())
                    self._check_arguments(spec, param, options_legal_inputs)
                    
                    if not self.bypass_checks:
                        self._check_mutually_exclusive(v.get('mutually_exclusive', None), param)
                    self._set_defaults(pre=True, spec=spec, param=param)
                    if not self.bypass_checks:
                        self._check_required_arguments(spec, param)
                        self._check_argument_types(spec, param, new_prefix)
                        self._check_argument_values(spec, param)
                        self._check_required_together(v.get('required_together', None), param)
                        self._check_required_one_of(v.get('required_one_of', None), param)
                        self._check_required_if(v.get('required_if', None), param)
                        self._check_required_by(v.get('required_by', None), param)
                    self._set_defaults(pre=False, spec=spec, param=param)
                    
                    self._handle_options(spec, param, new_prefix)
                self._options_context.pop()
    def _get_wanted_type(self, wanted, k):