Improve JsonPatch diff performances

[satabin]

The diffing algorithm was really slow in case of big collections and deeply nested structures.
The main reasons were:

• the JSON equality test done at the beginning wen through the entire JSON structure figuring out the deeply nested values were not equal
  • this equality is now performed only if we know both JSONs are not arrays or objects
• hashes were recomputed over and over again in the Patience LCS computation
  • this was due to a refactoring losing the fact that we use cached hashes, so this switched back to using the hash caching LCS.
• a lot of list concatenation append, each being O(n) in best case (reverse_:::)
  • switching to Chain greatly improves collection appends
• when diffing objects, fields were tested for equality at each level, resulting in doing the recursive equality check again and again
  • the object diffing method now traverses the objects only once, computing equalities on the go

Moreover on deeply nested structures, the call stack was exploding. Since the diff methods are mutually recursive, tail recursion elimination was not easy to achieve. The new implementation switches to Eval internally to make the recursive calls stack safe.

Below the results of the benchmarks for big arrays and deeply nested objects.

Before:

Benchmark                             Mode  Cnt     Score    Error  Units
PatienceBenchmarks.diffArray         thrpt    5  1469.334 ± 20.458  ops/s
PatienceBenchmarks.diffDeep          thrpt    5   493.050 ± 14.758  ops/s

After:

Benchmark                             Mode  Cnt     Score    Error  Units
PatienceBenchmarks.diffArray         thrpt    5  1857.889 ± 40.768  ops/s
PatienceBenchmarks.diffDeep          thrpt    5  1453.636 ± 33.049  ops/s

[ybasket]

Some mostly syntactic suggestions and one remark about dependencies, but looks good overall 👍

[ybasket]

Suggested change

	"io.circe" %% "circe-literal" % circeVersion
	"io.circe" %% "circe-core" % circeVersion

You don't seem to use literal, just syntax from core.

[ybasket]

Suggested change

	Eval.now(Chain.fromSeq(fields2.toList).map { case (fld, value) => Add(path / fld, value) })
	Eval.now(Chain.fromSeq(fields2.toList.map { case (fld, value) => Add(path / fld, value) }))

I'm pretty sure map is slightly faster on List. I also wonder whether one can go more directly from Map to Chain, but you probably tried already.

[ybasket]

Suggested change

	yield Remove[Json](path / idx, if (rememberOld) Some(arr(idx - shift)) else None))
	yield Remove[Json](path / idx, Option.when(rememberOld)(arr(idx - shift))))

[ybasket]

Suggested change

	_.prepend(Remove(path / fld, if (rememberOld) Some(value1) else None)))
	_.prepend(Remove(path / fld, Option.when(rememberOld)(value1))))