[BUG] Concat duplicates errors (or lack there of)
- [ ] closes #6963
- [ ]  xref #36263, #36290
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry

@jreback

So here is a basic proposal for making `concat` throw a more useful error when there are duplicate values on the index not being concatenated along. Below are some examples of how this error message is improved. I'm including a comparison to 1.2.0rc1, since it includes a pr which was supposed to change some of these errors to working cases, but those cases are extremely limited. That's why the first commit of this PR reverts that change.

I haven't gone too far with this since it a) reverts a merged PR and b) affects the release candidate, so should be conservative. I would like to get feedback on whether I should proceed with this approach.

My thinking right now is that a better error and revert should go into 1.2 – no behaviour change from 1.1, just better errors. A question of whether `pd.concat(..., join="inner")` means an intersection of indices (the current [and documented](https://pandas.pydata.org/docs/user_guide/merging.html#concatenating-objects) behaviour) or an actual inner join seems like something that could benefit from more discussion.

If they are set operations, it should probably error on duplicates. If they are relational algebra operations, they should work with duplicates. It would probably also be useful to then add more arguments to `concat`, like `merge`s `validate`.

# One dataframe has repeated column names (str)

```python
pd.concat([
    pd.DataFrame(np.ones((4, 4)), columns=list("aabc")),
    pd.DataFrame(np.ones((4, 3)), columns=list("abc")),
])
```

This PR

```pytb
InvalidIndexError: Reindexing only valid with uniquely valued Index objects
```

Pandas v1.1.5

```pytb
ValueError: Plan shapes are not aligned
```

pandas 1.2.0rc1

```pytb
ValueError: Plan shapes are not aligned
```

-------------------------

# One dataframe has repeated column names (int)

```python
pd.concat([  # One dataframe has repeated column names
    pd.DataFrame(np.ones((4, 4)), columns=[1, 1, 2, 3]),
    pd.DataFrame(np.ones((4, 3)), columns=[1, 2, 3]),
)
```

This PR

```pytb
InvalidIndexError: Reindexing only valid with uniquely valued Index objects
```

Pandas v1.1.5

```pytb
ValueError: Plan shapes are not aligned
```

pandas 1.2.0rc1

```pytb
ValueError: Plan shapes are not aligned
```


--------------------------

# Repeated columns (same amount) different column ordering

```python
pd.concat([
    pd.DataFrame(np.ones((2, 4)), columns=list("aabc")),
    pd.DataFrame(np.ones((2, 4)), columns=list("abca")),
])
``` 

This PR:

```pytb
InvalidIndexError: Reindexing only valid with uniquely valued Index objects
```

In pandas v1.15

```pytb
AssertionError: Number of manager items must equal union of block items
# manager items: 3, # tot_items: 4
```

In pandas v1.2.0rc1

```pytb
AssertionError: Number of manager items must equal union of block items
# manager items: 3, # tot_items: 4
```

----------------------------

# Repeated columns of different values in each

This point is what the reverted PR was trying to fix. This demonstrates that it didn't seem to fix what it set out to, and that the intended fix introduced strange behaviour anyways. To do this, I'll use the reverted test case.

```python
# Test case from previous PR
a_int = pd.DataFrame([1, 2, 3, 4], index=[0, 1, 1, 4], columns=["a"])
b_int = pd.DataFrame([6, 7, 8, 9], index=[0, 0, 1, 3], columns=["b"])

# Same, but with string indexes
a_str = a_int.set_index(letters[a_int.index])
b_str = b_int.set_index(letters[b_int.index])
```

## Int index

```python
pd.concat([a_int, b_int], axis=1)
```

This PR

```pytb
InvalidIndexError: Reindexing only valid with uniquely valued Index objects
```

Pandas v1.1.5

```pytb
ValueError: Shape of passed values is (8, 2), indices imply (6, 2)
```

pandas 1.2.0rc1

```pytb
     a    b
0  1.0  6.0
0  1.0  7.0
1  2.0  8.0
1  3.0  8.0
3  NaN  9.0
4  4.0  NaN
```

<details>
<summary> This behaviour is a bit strange </summary>

First, the `concat` documentation [defines the options here as set operations, like intersect and union](https://pandas.pydata.org/docs/user_guide/merging.html#concatenating-objects). Is this a union, or is this an outer join?

If these are joins, then inner joins only seem to work when they are equivalent to intersections:

```python
>>> pd.concat([a_int, b_int], axis=1, join="inner")
...
ValueError: Shape of passed values is (3, 2), indices imply (2, 2)

>>> pd.merge(a_int, b_int, how="inner", left_index=True, right_index=True)
   a  b
0  1  6
0  1  7
1  2  8
1  3  8
```

</details>


## str index

This is mostly just to show the behaviour in 1.2.0rc1 is different for string and int indices

```python
pd.concat([a_str, b_str], axis=1)
```

This PR

```pytb
InvalidIndexError: Reindexing only valid with uniquely valued Index objects
```

Pandas v1.1.5

```pytb
ValueError: Shape of passed values is (5, 2), indices imply (4, 2)
```

pandas 1.2.0rc1

```pytb
ValueError: Shape of passed values is (5, 2), indices imply (4, 2)
```
