Implement R.evolve

evolve :: { k: (v → v) } → { k: v } → { k: v }
======

For the proposal, see: ramda/ramda#648
I personally prefer shallow clone, since it matches better with JavaScript semantics and in theory should have better performance, especially for large data structures.

For example, the data structure for the builder in my comment in #648 looks like this:

```
Builder :: { notes :: [Note], active: { [noteId]: start :: Event } }
```

In the end, `notes` will contain a large array of Note objects, which are plain JavaScript Objects. Having to clone each and every Note each time we process an event can make the builder very slow.

If I want to speed up the Note building process, I can change the data structure to cons pairs. This will not improve performance if the state object is deep-cloned.

```
Cons<T> :: nil | [T, Cons<T>]
Builder :: { notes :: Cons<Note>, active: { [noteId]: start :: Event } }
```

By grepping the source, I don't see any function in Ramda that performs a deep clone. I propose to add a phrase to the documentation that it is a shallow clone, and a last sentence from `R.assoc`.

> All non-primitive properties are copied by reference.