Use keyof/lookup types to type Lens.key

[blacktaxi]

The property expression approach to create lenses has been very useful, but has always been a hack. The fact that we parse the property expression function's source code with regular expressions at runtime doesn't inspire any confidence just from its description alone. We also had several problems integrating with different instrumentation tools.

This PR implements alternative approach to create lenses and views. It's just as type safe as the property expression way. It also allows you to use the auto-completion feature (only tested in VSCode though).

The rename refactoring unfortunately doesn't work with string keys. Maybe we can find a workaround, or maybe we can decide to live with it. I would like to deprecate the property expression thing at some point, but would only like to do that if it will not significantly worsen the development UX.

Changes in this PR:

• [x] Another Lens.key overload that looks like this:

  function key<TObject = any>():
    <K extends keyof TObject>(k: K) => Lens<TObject, TObject[K]>

• [x] Atom.view and Atom.lens overloads to do keyof-typed views/lenses:

  view<K extends keyof T>(k: K): ReadOnlyAtom<T[K]>
  lens<K extends keyof T>(k: K): Atom<T[K]>

  This also adds several variadic overloads (up to 5 nested keys) for both .view and .lens.

• [x] Changed examples to use this new feature instead of property expressions.
• [x] Removed Lens.unsafeKey. Not even sure what was the original idea behind it, it's not used anywhere ATM.
• [x] Some cleanup here and there.
• [x] Add JSDocs to new overloads.