ENH: Function to make categories the same across several Categoricals
#### Motivation

We often want to make vectorized comparisons between two Categoricals. However, this is not possible unless they have the same categories:

```python
In [45]: A = pd.Categorical([10, 33, 24, 33, 10])

In [46]: A
Out[46]:
[10, 33, 24, 33, 10]
Categories (3, int64): [10, 24, 33]

In [47]: B = pd.Categorical([33, 21, 24, 33, 10])

In [48]: B
Out[48]:
[33, 21, 24, 33, 10]
Categories (4, int64): [10, 21, 24, 33]

In [49]: A == B
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-49-acc3d1f167fc> in <module>
----> 1 A == B
...
    143             msg = "Categoricals can only be compared if 'categories' are the same."
    144             if not self._categories_match_up_to_permutation(other):
--> 145                 raise TypeError(msg)
    146
    147             if not self.ordered and not self.categories.equals(other.categories):

TypeError: Categoricals can only be compared if 'categories' are the same.
```

#### Proposed solution

It would be useful to have a utility function which takes two or more Categoricals as input and re-encodes each of them using the union of their respective categories as the new categories. This is very similar to what `union_categoricals` does, except that outputs a concatenation of the input Categoricals.

Here is a basic implementation which I have used, with apologies for my lack of knowledge of Pandas internals:
```python
In [50]: def unify_categoricals(*categoricals):
    ...:     all_categories = set(itertools.chain(*[c.categories for c in categoricals]))
    ...:     for categorical in categoricals:
    ...:         new_categories = all_categories.difference(set(categorical.categories))
    ...:         if new_categories:
    ...:             categorical.add_categories(new_categories, inplace=True)
    ...:

In [51]: unify_categoricals(A, B)
<ipython-input-50-e69ac645c9fb>:6: FutureWarning: The `inplace` parameter in pandas.Categorical.add_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.
  categorical.add_categories(new_categories, inplace=True)

In [52]: A
Out[52]:
[10, 33, 24, 33, 10]
Categories (4, int64): [10, 24, 33, 21]

In [53]: B
Out[53]:
[33, 21, 24, 33, 10]
Categories (4, int64): [10, 21, 24, 33]

In [54]: A == B
Out[54]: array([False, False,  True,  True,  True])
```

This could be modified to avoid inplace operations on the input Categoricals and extended to support ordered Categoricals as well. The name is probably too similar to `union_categoricals`; suggestions are appreciated.

#### API breaking implications

None

#### Alternatives

For one-off comparisons, you can get away with simply decoding the Categoricals:
```python
In [55]: A.to_numpy() == B.to_numpy()
Out[55]: array([False, False,  True,  True,  True])
```
There is only a real benefit if you need to make many comparisons (for my application, we persist DataFrames to Feather files and load them into memory for many different tasks, so it is useful to perform this conversion once before storage). Since this is somewhat of a niche use case it could be left to application code.

There might also be some way to chop up the output of `union_categoricals` into multiple Categoricals which are the re-encoded versions of the inputs.