…rned (#443)

* lazy_image: fix cache collisions leading to unrelated data being returned

Currently, the key used to look up the cached image is based on a hash of
a tuple containing `id(self)`, `path`, and `loader`. This means there are two
situations in which a `lazy_image` can look up the wrong data:

* If there previously existed another `lazy_image` object whose `self` and
  `loader` had the same object IDs as the current `lazy_image`'s `self` and
  `loader`. This is possible, because deleted objects' IDs can be reused.

* If a hash collision occurs between the current `lazy_image`'s tuple and
  some other's.

Fix it by using a weak reference to `self` as the key instead. Different weak
references will only compare equal if they point to the same object.

This will only work correctly if the loader and path of a `lazy_image` are
not modified after creation. I don't think there are any use cases for
modifying them (and there are no instances of that happening in the codebase),
so it shouldn't be an issue. To reduce the temptation of client code to modify
these fields, mark them as private.

Modifying the `cache` field should not cause issues, but just in case, make it
private as well.

* Add a changelog entry for the lazy_image cache collision fix

* Replace rollback with scope

* Add scope_add() function

* Update tests

* Replace rollback uses

* Update changelog