DataFrame.merge behavior unclear when both indices and data columns are keys
#### Code Sample, a copy-pastable example if possible

```python
import pandas as pd

a = [4,6,9,5,2,4]
pleft = pd.DataFrame.from_dict({'a':a})
pright = pleft.copy(deep=True)

# Make two indices to also be used as join columns
pleft.index = [6,5,4,7,5,5]
pright.index = [5,4,1,9,4,3]
pd_result = pleft.merge(pright, on='a', left_index=True, right_index=True, how='inner')
print('lhs:')
print(pleft)
print('rhs:')
print(pright)
print('result:')
print(pd_result)
lhs:
   a
6  4
5  6
4  9
7  5
5  2
5  4
rhs:
   a
5  4
4  6
1  9
9  5
4  2
3  4
result:
   a
4  9
4  9
5  6
5  2
5  4
```
#### Problem description

Hello, I'm hoping someone here can clarify the behavior I'm seeing when merging dataframes using certain combinations of `left_index/right_index`, and `on`.

We can use `on` to specify a key that exists in both operands, or `left_on`/`right_on` if the keys are potentially named something different on each side. We can use `left_index` and `right_index` if we want to merge on the index column, or even `left_index` and `right_on` or (or vise versa) if we want one key to be an index, and the other to be a data column. As such I'd expect that using `left_index` and `right_index` as well as `on` would perform a merge that matches records on both the index as well as whatever data columns are specified. But it appears this is not the case.


#### Expected Output

```python
   a
5  4
```

The pandas result appears to be more like what I'd get merging on just the indices and not the column `a`. I then wondered if the docs said anything about the index argument having some sort of precedence over `on`, but I didn't see anything - forgive me if I missed something here. What's more is if I manually omit `on`, I actually get something a little different:

```
result = pleft.merge(pright, left_index=True, right_index=True, how='inner')
print(result)
   a_x  a_y
4    9    6
4    9    2
5    6    4
5    2    4
5    4    4
```


One might argue that if the index arguments take precedence, I should get the same result that I would as if I didn't pass `on` at all. 

#### Output of ``pd.show_versions()``

<details>

[paste the output of ``pd.show_versions()`` here below this line]
INSTALLED VERSIONS
------------------
commit           : None
python           : 3.7.6.final.0
python-bits      : 64
OS               : Linux
OS-release       : 4.4.0-134-generic
machine          : x86_64
processor        : x86_64
byteorder        : little
LC_ALL           : None
LANG             : en_US.UTF-8
LOCALE           : en_US.UTF-8

pandas           : 0.25.3
numpy            : 1.18.1
pytz             : 2019.3
dateutil         : 2.8.1
pip              : 20.0.2
setuptools       : 45.2.0.post20200209
Cython           : 0.29.15
pytest           : 5.3.5
hypothesis       : 5.5.4
sphinx           : 2.4.3
blosc            : None
feather          : None
xlsxwriter       : None
lxml.etree       : None
html5lib         : None
pymysql          : None
psycopg2         : None
jinja2           : 2.11.1
IPython          : 7.12.0
pandas_datareader: None
bs4              : None
bottleneck       : None
fastparquet      : None
gcsfs            : None
lxml.etree       : None
matplotlib       : None
numexpr          : None
odfpy            : None
openpyxl         : None
pandas_gbq       : None
pyarrow          : 0.15.0
pytables         : None
s3fs             : None
scipy            : None
sqlalchemy       : None
tables           : None
xarray           : None
xlrd             : None
xlwt             : None
xlsxwriter       : None
</details>
