REF: Dependency Structure Simplification
This is intended to describe a) possible refactors that would simplify the intra-pandas dependency structure, b) the benefits we would see from implementing these refactors, and c) the difficulties each would entail.

<b>Straightforward Circular Dependencies</b>
- [ ] imports from `pd.core.util.hashing` in `pd.util.__init__`
  Fix: Just remove that import, difficulty depends on if that needs a deprecation cycle.
- [ ] runtime import of `tseries.frequencies.to_offset` into `tslibs`
  Fix: Move most of tseries.offsets and about half of tseries.frequencies into tslibs
    - `tseries.offsets.generate_range` is the only part of `tseries.offsets` that is not needed; it can go to `arrays._ranges`, which is the only place where it is used
    - `tslibs.offsets` would become a very big module unless it were split into smaller pieces
    - `cache_readonly` is needed by some classes in `tseries.offsets` (which would be moved to `tslibs.offsets`), would need to put somewhere "upstream" of tslibs.
- [x] `_libs.internals` runtime import of `Int64Index`
   - For `BlockPlacement.isin`, which is only used in one place in `core.internals`, the `isin` method could be refactored out of the class.
   - This one is really only worthwhile if we expect to implement tests/benchmarks specific to `_libs.internals` 
- [x] runtime import of `pd.unique` in `IntervalTree.get_loc_interval`
   - I _think_ its the case that the argument passed to pd.unique is always int64 (@jschendel is this accurate?).  If so, implementing a `unique_int64` in either `_libs.hashtables` or `_libs.algos` takes about 3 lines, could be a nice fastpath for a very common case.

<b>core.dtypes</b>
- `core.dtypes.common` is used all over the place.  It would be really nice if its dependencies were simple.  But:
   - it imports `CategoricalDtype`, which has runtime imports from `pandas.core.util.hashing`, in particular functions that have runtime imports of `Categorical`, `Index`, `MultiIndex`, and `factorize`
   - `algorithms.factorize` has runtime imports from `pandas.core.sorting`, which has a dependency on `algorithms` and runtime import of `Index`.
   - I _think_ the "heavy" dependencies on `Categorical`/`Index`/`MultiIndex` are mostly just for the constructors and could be refactored into much lighter-weight implementations.  I'm imagining something like `core.factorization` that depended only on `_libs` and maybe a few of the `is_foo_dtype` functions (the latter would still be circular, but a much smaller circle)
