ENH: nullable Float32/64 ExtensionArray
As proposed at https://github.com/pandas-dev/pandas/issues/32265#issuecomment-627004139, this is adding a float extension dtype and array (for now avoiding/ignoring the NaN-discussion), using the masked array approach following our other nullable dtypes.

Brief overview:

- This PR adds a `FloatingArray` and `Float32Dtype` / `Float64Dtype` (similar as for the nullable integer dtypes)
- I am using the "Float64" pattern with capital "F" as name for the dtype to distinguish the string name of the "float64" dtype from numpy (consistent with Int64 etc)
- For now I only added Float32 and Float64 (we can see later if we want to add others like float16)
- Upon conversion of input (both in construction as in operations such as setitem), any `np.nan` is coerced to NA (we can see later to add an option / config for this)
- The added tests are for now mostly copied from the existing integer/boolean tests, and adapted for Float
- It directly uses some of the masked ops I implemented earlier for IntegerArray, which means that eg `sum` already shows a similar perf benefit:
  ```python
  a = np.random.randn(1_000_000) 
  a[np.random.randint(0, 1_000_000, 100)] = np.nan 
  s1 = pd.Series(a)
  s2 = pd.Series(a, dtype="Float64")

  In [6]: np.allclose(s1.sum(), s2.sum()) 
  Out[6]: True

  # numpy float series
  In [7]: %timeit s1.sum()   
  2.73 ms ± 104 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

  # nullable float series
  In [8]: %timeit s2.sum()   
  875 µs ± 18.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
  ```

- Still to do:
    - [x] Add whatsnew + docs
    - [ ] Division with Int64 dtype can now result in nullable Float Dtype instead of numpy float array

- Other todo's but that can probably be left for follow-up PRs:
    - Update the `convert_dtypes` method to also return nullable floats (one question here: what with floats that are all "integer"-like? I think we want to keep returning nullable int for that, but we might want to add a parameter controlling that behaviour?)
    - Some more arithmetical operations with IntegerArray/BooleanArray can now return a FloatingArray instead of numpy float array
    - Ufuncs on IntegerArray/BooleanArray can return FloatingArray, ufuncs on mixture of IntegerArray/FloatArray
    - Consolidate some tests that are common for integer/boolean/float
    - Deduplicate more things between the Array classes and move to BaseMaskedArray (eg the arithmetic / comparison ops can probably be moved with a bit of refactoring)
        - `__from_arrow__`
        - ufuncs
        - `coerce_to_array`, but this will probably require some refactoring
  - formatting options


