`Error::from_iter`: a convenient method for combining multiple errors

In many projects I define the following method to combine multiple errors into a single one, and I think it may be useful to many devlopers to have sometihng similar directly in `syn`. Something like `syn::Error::from_iter(errors)`.

```rs
fn combine_errors(errors: impl IntoIterator) -> syn::Result<()> {
let mut errors = errors.into_iter();
if let Some(mut error) = errors.next() {
error.extend(errors);
Err(error)
} else {
Ok(())
}
}
```

With the following usage:

```rs
fn check_fn(fn_item: &ItemFn) -> syn::Result<()> {
let mut errors = Vec::new();

if let Some(abi) = &fn_item.sig.abi {
errors.push(syn::Error::new_spanned(
abi,
"use the default ABI",
));
}

if let Some(asyncness) = &fn_item.sig.asyncness {
errors.push(syn::Error::new_spanned(
asyncness,
"async functions are not supported",
));
}

if let Some(unsafety) = &fn_item.sig.unsafety {
errors.push(syn::Error::new_spanned(
unsafety,
"unsafe functions are not supported",
));
}

combine_errors(errors)
}
```