PERF: O(n) speedup in any/all by re-enabling short-circuiting for bool case
At present, the `.all()` and `.any()` functions scale as `O(n)`, more or less regardless of their exit condition being fulfilled:
```
$ asv run -b Any -b All upstream/master
[  0.01%] ··· series_methods.All.time_all                                                                                                                                                                 ok
[  0.01%] ··· ========= ============ ============
              --                   case          
              --------- -------------------------
                  N         fast         slow    
              ========= ============ ============
                 1000     115±3μs      123±5μs   
               1000000   11.1±0.2ms   13.6±0.1ms 
              ========= ============ ============

[  0.01%] ··· series_methods.Any.time_any                                                                                                                                                                 ok
[  0.01%] ··· ========= ============ ============
              --                   case          
              --------- -------------------------
                  N         fast         slow    
              ========= ============ ============
                 1000     118±2μs      117±3μs   
               1000000   14.0±0.2ms   11.6±0.4ms 
              ========= ============ ============

```
The root cause of this was identified by `asv find` to be https://github.com/pandas-dev/pandas/pull/8550, which was released as part of `v0.15.2`. Specifically, we call `isna()` on the entire input prior to dispatching to `np.all`/`np.any`; the latter does short circuit but is insignificant compared to `isna()`.

My proposal here is to exempt `np.bool` from the `isna()` call on the basis that it is not capable of storing `NaN` values; I'm hesitant to make this case much broader than necessary to accommodate calls like `pd.isnull(s).all()`. The `hasattr()` check is necessary due to a `Panel` test case directly invoking `nanall(Panel)`.

The good news is that this approach is very effective:
```
$ asv run -b Any -b All HEAD
[  0.01%] ··· series_methods.All.time_all                                                                                                                                                                 ok
[  0.01%] ··· ========= ============ ============
              --                   case          
              --------- -------------------------
                  N         fast         slow    
              ========= ============ ============
                 1000     59.8±1μs    60.9±0.7μs 
               1000000   73.7±0.4μs    138±4μs   
              ========= ============ ============

[  0.01%] ··· series_methods.Any.time_any                                                                                                                                                                 ok
[  0.01%] ··· ========= ========== ============
              --                  case         
              --------- -----------------------
                  N        fast        slow    
              ========= ========== ============
                 1000    59.7±1μs   59.7±0.8μs 
               1000000   75.7±1μs    133±3μs   
              ========= ========== ============
```
Additionally, this call is not too widely used within the `pandas` codebase as most invoke the `numpy` equivalent. That being said, we do see some broad speedups when running the entire suite:
```
$ asv compare ea013a25 37c2e7a2 -s --sort ratio --only-changed
       before           after         ratio
     [ea013a25]       [37c2e7a2]
     <master~1>       <master>  
-      10.4±0.2ms       9.41±0.1ms     0.90  timeseries.AsOf.time_asof('DataFrame')
-     1.54±0.03ms      1.39±0.01ms     0.90  groupby.GroupByMethods.time_dtype_as_group('float', 'rank', 'transformation')
-      38.3±0.8ms       34.3±0.6ms     0.90  stat_ops.FrameOps.time_op('median', 'float', 1, True)
-     1.18±0.03ms      1.05±0.01ms     0.89  groupby.GroupByMethods.time_dtype_as_group('int', 'cummax', 'direct')
-      23.2±0.3ms       20.8±0.2ms     0.89  groupby.MultiColumn.time_cython_sum
-     1.19±0.05ms      1.06±0.01ms     0.89  groupby.GroupByMethods.time_dtype_as_group('datetime', 'cummin', 'direct')
-         128±1ms          114±2ms     0.89  indexing.CategoricalIndexIndexing.time_get_indexer_list('non_monotonic')
-     4.12±0.08ms      3.64±0.08ms     0.88  indexing.NumericSeriesIndexing.time_loc_list_like(<class 'pandas.core.indexes.numeric.Int64Index'>, 'unique_monotonic_inc')
-     1.23±0.02ms      1.09±0.01ms     0.88  groupby.GroupByMethods.time_dtype_as_group('float', 'cummax', 'transformation')
-     1.20±0.04ms      1.06±0.02ms     0.88  groupby.GroupByMethods.time_dtype_as_group('float', 'cummin', 'direct')
-     1.20±0.02ms      1.06±0.01ms     0.88  groupby.GroupByMethods.time_dtype_as_field('int', 'cumsum', 'direct')
-     10.5±0.08ms       9.12±0.3ms     0.87  timeseries.AsOf.time_asof_nan('DataFrame')
-      6.30±0.3ms       5.46±0.2ms     0.87  indexing.NumericSeriesIndexing.time_loc_array(<class 'pandas.core.indexes.numeric.Int64Index'>, 'unique_monotonic_inc')
-     1.55±0.04ms      1.34±0.02ms     0.86  groupby.GroupByMethods.time_dtype_as_group('datetime', 'rank', 'transformation')
-         130±1ms        112±0.8ms     0.86  indexing.CategoricalIndexIndexing.time_get_indexer_list('monotonic_decr')
-      28.1±0.7ms       22.9±0.3ms     0.82  reshape.Cut.time_cut_float(10)
-      26.4±0.4ms         21.0±1ms     0.80  reshape.Cut.time_cut_float(4)
-        12.7±2ms       9.06±0.2ms     0.71  inference.DateInferOps.time_subtract_datetimes
-     4.33±0.05ms      3.03±0.04ms     0.70  timeseries.AsOf.time_asof_single('DataFrame')
-      1.04±0.2ms          681±7μs     0.66  groupby.GroupByMethods.time_dtype_as_group('int', 'median', 'transformation')
-     4.51±0.05ms      2.69±0.05ms     0.60  timeseries.AsOf.time_asof_nan_single('DataFrame')
-         112±2μs       59.5±0.8μs     0.53  series_methods.All.time_all(1000, 'fast')
-         115±2μs         60.7±1μs     0.53  series_methods.Any.time_any(1000, 'fast')
-         117±7μs         61.3±2μs     0.53  series_methods.All.time_all(1000, 'slow')
-         115±1μs         59.8±1μs     0.52  series_methods.Any.time_any(1000, 'slow')
-      2.39±0.6ms      1.20±0.01ms     0.50  stat_ops.SeriesOps.time_op('kurt', 'int', False)
-      2.45±0.6ms      1.21±0.01ms     0.49  stat_ops.SeriesOps.time_op('skew', 'int', False)
-      2.43±0.6ms      1.20±0.01ms     0.49  stat_ops.SeriesOps.time_op('kurt', 'int', True)
-      11.1±0.2ms        132±0.5μs     0.01  series_methods.Any.time_any(1000000, 'slow')
-      13.5±0.2ms          133±2μs     0.01  series_methods.All.time_all(1000000, 'slow')
-      10.9±0.3ms         74.9±1μs     0.01  series_methods.All.time_all(1000000, 'fast')
-      13.4±0.3ms         75.3±2μs     0.01  series_methods.Any.time_any(1000000, 'fast')
```
For the largest `n` tested, we see a speedup of `~170x` in the fast case.

- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
