Closes #3772

This PR does several improvements to when we can merge NumpyArrays together, to how we simplify UnionArrays using the simplified constructor and also as a result solves the original problem of comparing union arrays in almost_equal which is much deeper that I originally thought.

We do the following:

1. We introduce the ability to pass in the casting argument to the nplike can_cast method. That is because we want to use something else than the previously hard-coded "same_kind" in certain scenarios.
2. We introduce a new argument in the mergeable and _mergeable_next functions called mergecastable which can be either "same_kind" (the default), "equiv", or "family" (two of those three names are taken from numpy's can_cast method). We obviously pass around this new argument everywhere _mergeable_next is called (as that does not have default values, only the more public mergeable does). That new argument tells us when we can merge contents. Previously, we'd merge contents when they can be casted together and that remains that default (same_kind). So ints and floats could be merged together. With the two new options we can choose if we only want to merge contents of the same family (int32 and int64 for example but not ints and floats) with the "family" option" or we can only merge exact dtypes together (int32 with int32 only for example) with the "equiv" option. We upgrade the _mergeable_next implementation of NumpyArray to handle these options and keep the default behavior like it always was.
3. We expose this argument to the UnionArray.simplified constructor which tries to merge contents of the union together. So now we can choose if we want to merge ints and floats together for example and so on.
4. We introduce one extra argument in the UnionArray.simplified constructor and that is called dropunused. A union array may not use all of its contents. There may be contents that are not used ever in the tags and the simplification can drop those. Because a union array needs at least two contents to be instantiated, we take special care of the cases where one or zero contents are actually used only in order to avoid an __init__ error. That argument naturally has the default value False and will not try to drop unused contents unless explicitly asked for like it always has been.

All those are generally nice features to have and can be used in other contexts because there is not one single way to merge numpy arrays, nor to simplify union arrays. The default behavior hasn't been changed and all those features are opt-in of course.

Now back to the ak.almost_equal problem. The problem is the original algorithm assumed that there is a one-to-one map between the tags of the left array and the right array and that is not generally true as you can have repeated content dtypes in the unions, unused contents and so on.

We upgrade the algorithm as follows. The algorithm now for union arrays in ak.almost_equal uses this new simplified constructor and does the following:

1. Drops all unused contents of union arrays.
2. Simplifies the union arrays and merges ONLY identical dtypes if the dtype_exact argument is True and merges ONLY dtypes within families if it is False.
3. At this point, if two unions do not have the same number of contents, they are not equal and therefore returns False.
4. Proceeds with the original algorithm that assumes a one-to-one map between the tags of the left and right arrays.

over 1.5K lines of tests have been added to test all that.