API: Allow equality comparisons of Series with a categorical dtype and object type are allowed (GH8938)
closes #8938 

@jorisvandenbossche 
cc @shoyer
cc @JanSchulz
cc @immerr

?
 Probably want to make sure `!=` works, too.
 @shoyer good point, fixed up.
 This should also get some updates in categorical.rst. Want to get a patch?
 @JanSchulz if you want to post a patch all ears! (for docs)....i'll fix the other in a minute
 Patch is at #8952
 What I started to wonder when I did the docs: if `cat > scalar` is allowed and `cat == list` also because it basically is doing a comparison of each line as if it was the scalar case, then by that logic, `cat > list` should also be allowed: each row in that comparison would treat the element from the list as a scalar. 

On the other hand a scalar comparison with the categorical makes only sense if the scalar can be treated as a category (for any other value, it's basically a "not of the same type" comparison, which would raise on python3), so the scalar must be in `categories` and this should not work:

```
In[4]: df = pd.DataFrame({"a":[1,3,3,3,np.nan]})
In[6]: df["b"] = df.a.astype("category")
In[7]: df.b
Out[7]: 
0     1
1     3
2     3
3     3
4   NaN
Name: b, dtype: category
Categories (2, float64): [1 < 3]
In[8]: df.b > 2
Out[8]: 
0    False
1     True
2     True
3     True
4    False
Name: b, dtype: bool
```
 @JanSchulz I can kind of buy that last example we would 'like' to work (as it seems natural), but it does violate the Categorical principles.

Ok, how about we merge this to fix the equalitiy inconsistency with merging then open a new issue for discussion about non-equal comparisons.

@shoyer 
@jorisvandenbossche 

?
 @JanSchulz ok on this?
 Jep, I'll open a new issue with that..
 Oh, one more thing: according to that thought, `df.b == 2` (-> The "equality" case) should also NOT work, because `2` is not in `categories` and therefore a "different type".
 @JanSchulz gr8 thanks
 ```
In [5]: df.b==2
Out[5]: 
0    False
1    False
2    False
3    False
4    False
Name: b, dtype: bool
```

this is actually consistent (e.g. it returns `False`). On a comparison it shouldn't raise so this is a reasonable result. I think this is de-facto like the following and is useful.

```
In [7]: Series(['a','b','c'])==2
Out[7]: 
0    False
1    False
2    False
dtype: bool
```
