Improved pl_true
Added documentation and tests.
minor tweaks
do not dispatch to re/im when all factors are already known

Refactor so re and im will not have to re-calculate all that has
already been separated.
7374: process n < 10 in factorint even when limit > 1
Merge pull request #7919 from smichr/real1

do not dispatch to re/im when all factors are already known
Merge pull request #7924 from smichr/7374

7374: process n < 10 in factorint even when limit > 1
clean up docstrings in sets
use ordered to handle Set args: define infimum_key

The sort_key is insufficient to differentiate between the arguments. I demonstrate by using an Interval and FiniteSet

```
>>> I = Interval(0, 5); S = FiniteSet(1, 2, 3)
>>> from sympy.core.compatibility import default_sort_key as k
>>> k(I)
((1, 0, 'Number'), (0, ()), (), 0)
>>> k(S)
((1, 0, 'Number'), (0, ()), (), 1)
```

This is because the infimum was being used sucessfully to (unsuccessfully) represent the objects being sorted. The better approach is to use ordered and let the infimum be the default sort key -- and thus fast if the infimums are sufficient to break ties -- else fall back to the default_sort_key for the object.

In addition, the sorting of args was done before the evaluation. I moved this to after the evaluation since those are the actual args that will be stored (and a quick glance at an evaluation routine didn't make it look like it assumed the arg were already sorted).
fix Partition docstrings [skip ci]

Tested locally

It appears that now these Partitions are being sorted as the docstring
states: by size and then according to the members in the sets.
is_zero and free_symbols modifications

is_zero is needed to identify alternate *trivial* forms of 0 as
in Integral(0, ...). It should never do more than look for a literal
0 someplace. For this reason, the Integral.is_zero routine was modified
and the advanced processing for other mostly trivial cases of an integral
being 0 was moved to the doit method.

foo.is_number is equivalent to not foo.free_symbols but is a faster way of
arriving at that answer because is_number will fail if a single free
symbol is encountered. For this reason, the Integral.is_number routine
was modified.

foo.free_symbols should give any free symbols in the expression *as
written* without any regard to whether those symbols will disappear after
simplification of some sort. The test for is_zero was removed from
expr_with_limits calculation of free symbols for this reason.

Other comments about the rationale of these changes are in the test
suite (esp in test_basic) so that anyone changing the behavior will be
sure to see the desired state of affairs.
move Integral.is_zero to _eval_is_zero
make log._eval_is_zero more naive: no simplification
remove redundant is_number routines
change is_zero to _eval_is_zero for Sum and Product
make Product and Sum is_number more naive

is_number is a yes or no question equivalent in answer to
not foo.free_symbols. It should not use evaluation or assumptions
to answer the question.
update comment [skip ci]
consolidate is_number and free_symbols into base classes
remove Integral.is_number; use super class routine
for speed, put is_number with low level classes