inverse transform break chaining

Nobody has claimed this yet.

### Bug report

**Bug summary**

Transform chaining seems to not be possible in some cases. As an example
```
tr = ax.transAxes - ax.transData + ax.transData
```
gives a different result than
```
tr = ax.transAxes
```
although those are linear transformations, which can easily be inverted, so one would expect
```
A + B^-1 + B == A
```
The following example shows that this is not the case.

**Code for reproduction**

The code should create a red and a green line from [0,0] to [1,1] in axes cooridinates. Yet the red line is somehow fixed to its initial prosition and forgets about its transform.

```
import matplotlib.pyplot as plt

fig, ax = plt.subplots()

# apply transform A + B^-1 + B
# this should equal A
tr = ax.transAxes - ax.transData
trinv = ax.transData
line = plt.Line2D([0,1],[0,1],transform=tr+trinv, color="crimson")
ax.add_line(line)

# apply transform A
line2 = plt.Line2D([0,1],[0,1],transform=ax.transAxes, color="limegreen")
ax.add_line(line2)

ax.set_ylim(.1,1.1)

plt.show()
```

**Actual outcome**


**Expected outcome**

A plot with red and green line overlapping.

Now it may well be that I'm completely misunderstanding the transform chaining in which case it would probably be good to update the documentation.

**Matplotlib version**

* Operating system: Windows 8.1
* Matplotlib version: 2.2
* Matplotlib backend: Qt4Agg as well as TkAgg
* Python version: 2.7.10

Start by running the provided Python reproduction with ax.transAxes, ax.transData, and Line2D, then inspect the transform-chaining behavior involved in A + B^-1 + B. Compare the red and green lines after ax.set_ylim(.1, 1.1). Done means the chained transform matches ax.transAxes, or the transform documentation clearly explains the expected behavior.

Written by the indexing model from the issue text.