`ufuncify` makes actual ufuncs

This is a rough pass at getting ufuncify to make actual ufuncs. It
works, but needs some cleanup, optimizations, tests, and documentation.
Ufuncify backends, code cleanups

- Brought back backends for F2Py and Cython. These now support
  broadcasting on all arguments, but mandate that the arguments be
  1-dimensional arrays of the same length.
- Default backend is the new `numpy` backend, which creates actual
  `ufunc`s.
- Code cleanups, improved docstrings, added tests.
Codewrappers infer/validate language from backend

In `autowrap` and `ufuncify`, the `language` kwarg now defaults to
`None`. In this state, the language is inferred from a lookup table of
backend -> tuple of languages, with the highest preference first. If the
language is specified, it is validated using this same lookup. This
prevents specifying `backend='f2py', language='c'`, and also allows the
user to only specify the backend to change behavior.

Also made some touchups to docstrings and tests.
Merge remote-tracking branch 'upstream/master' into ufuncify_improvements

Conflicts:
	sympy/utilities/autowrap.py
Cache calls to `ufuncify`

- `ufuncify` is not cached
- Small fix to `autowrap` docstring
Change ufuncify and autowrap signature

Kwargs now default None, not ().
`sympify` input to codeprinters

Ensures expression is hashable. Fixes issue #7980.
Removed unused "tests" variable.  setup() now uses find_packages()
Adopt classifiers to include py3.4
Document where should be changed __version__
Re-use sympy.__doc__ as the long_description kwarg for setup()
Don't use setup_args, use setup() kwargs directly
Relational: Unify `Lt` and `<`, a fix for pr #7783

Make long form and symbolic operators take the same path through the code.
This effects `Lt`, `Gt`, `Ge`, `Le`, their longer forms (`StrictLessThan`,
etc) and the symbolic versions (`<`, etc) which call `__lt__` etc.

Here is an outline of the approach:

1. If we come via `__lt__` than we do all we can to reduce to bool or
raise exception.  This can go through several classes' `__lt__` methods,
but in the end (currently `Expr.__lt__`) we ask `Lt` to make a
non-evaluated inequality with `evaluated=False`.

2. On the other hand, if we come from `Lt(lhs, rhs)`, we first ask
`lhs.__lt__(rhs)`.  Which will then either return a boolean, raise an
exception or eventually call `Lt` again but with `evaluated=False` as
above.

In this fashion, we always have the same result whichever form we called.
test_relational: fix some incorrect tests

`Gt(I, 2)` is supposed to raise TypeError, not give `false`.
Inequalities: UnXFAIL tests from pr #7783
Relational: don't use symbol ops `<` in `Lt` lest it reorder arguments

I encountered and filed issue #7951, where `x < p` can become `p > x`
even when both are sympified.  This adds tests.  Issue causes failures
in `meijerint._condsimp` and more specifically `subs` where an `cls=Wild`
variable was substituted for a regular symbol in an Inequality.

As a workaround (which is probably safer against this sort of bug), we
call `__lt__` and friends instead of the symbols.
test_relational: better tests for ineq flip test

Perhaps issue 7951 not fixable, so replace XFAIL test with a test
that specifically tests the workaround I put in place.
Add test for the issue 5673

closes #5673
Relational: if simplify lhs/rhs not enough, try harder with equals(0)

Call `_eval_sides` when simplifying inequalities (this can be expensive
so we first try the existing simplify lhs/rhs approach).

A consequence of unifying `Lt` and `<` (the fix for pr #7783) is that
`_eval_sides` is no longer called in `Relational.__new__`.  Sometimes
this meant inequalities did not reduce to boolean when they did before.
Now we have the essentially the same code: if an expression previously
reduced to bool upon creation, it should now do so after simplify().
fix tests that fail due to Inequalities no longer simplifying automatically

Just a matter of putting `simplify()` around them.