Fix concurrent memoization of zero-arg methods multiple values

[ms-ati]

When two threads concurrently call a zero-arg method which is in
the unmemoized state, they can return two different results.

For example, this could occur if we are memoizing:

• database query result
• filesystem read
• current time
• a random number

This PR adds documentation that this is expected behavior to README.md,
as well as a probabilistic spec that demonstrates the behavior.

[codecov]

Codecov Report

Merging #230 (6bdfea1) into main (f2cdecf) will not change coverage.
The diff coverage is n/a.

❗ Current head 6bdfea1 differs from pull request most recent head 785856a. Consider uploading reports for the commit 785856a to get more accurate results

@@            Coverage Diff            @@
##              main      #230   +/-   ##
=========================================
  Coverage   100.00%   100.00%           
=========================================
  Files            2         2           
  Lines          201       201           
=========================================
  Hits           201       201           

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update f2cdecf...785856a. Read the comment docs.

[ms-ati]

As expected: this purely ruby code "double check" pattern, where we check again whether the memoization sentinel has been set in a concurrent thread after we have run the original method, appears to be successful in all test runs on all MRI versions, but sometimes fails on JRuby.

Options

1. We could leave the code in its prior state, and document that contended calls can result in different return value across threads on all Ruby versions
2. We could adopt this solution for MRI, and document that it doesn't work on JRuby in both markdown and tests (e.g. by marking this test as "pending" in JRuby)
3. We might go a step further and use a Mutex on each object, which would fix this issue on all Ruby versions, at some additional cost on those first calls where we set the memoized value

I'm hoping that this PR can help kick off a discussion and we can intentionally select an option 😄

[ms-ati]

Summary of discussion with @jemmaissroff and @JacobEvelyn outside of Github:

• We've selected Option 1: leave code in its prior state, and document that contended calls can result in different return values across threads
• Why?
  • 1. Because memoization of a non-deterministic method is an app-by-app decision. It's not a memoization library's place to institute a single policy and expectation of what should be memoized and returned in each thread, whether any given concurrency primitive should be employed, etc
  • 2. Because memoization of a deterministic method already works safely under contention, although the underlying method may be called multiple times
• Next steps:
  • Document the behavior via both writing and specs
  • Add examples of how the code that uses MemoWise can employ a Mutex if desired

[JacobEvelyn]

Just some minor comments. Thanks for working on this!

Also, consider adding this to the bottom of your commit message:

Closes #184