ImmSet optimisation for multi inserts or multi deletions

[DamianSawicki]

Please ensure your pull request adheres to the following guidelines:

• For first time contributors, read Submitting a pull request
• All code is covered by unit and/or runtime tests where feasible.
• All commits contain a well written commit description including a title,
  description and a Fixes: #XXX line if the commit addresses a particular
  GitHub issue.
• If your commit description contains a Fixes: <commit-id> tag, then
  please add the commit author[s] as reviewer[s] to this issue.
• All commits are signed off. See the section Developer’s Certificate of Origin
• Provide a title or release-note blurb suitable for the release notes.
• Are you a user of Cilium? Please add yourself to the Users doc
• Thanks for contributing!

This PR proposes new implementations with lower computational complexity of the following methods of ImmSet :

• func (s ImmSet[T]) Insert(xs ...T) ImmSet[T],
• func (s ImmSet[T]) Delete(xs ...T) ImmSet[T],
• func (s ImmSet[T]) Difference(s2 ImmSet[T]) ImmSet[T],
• func (s ImmSet[T]) Union(s2 ImmSet[T]) ImmSet[T].

The first commit of the PR contains benchmarking comparing the existing and the new implementation. For me, the results were as follows:

• for Insert, the proposed method becomes faster already with the container of size 1000, and then it performed 10x faster for size 10,000 and 100x faster for size 100,000;
• for Delete, the proposed method becomes faster already with the container of size 1000, and then it performed ~5x faster for size 10,000;
• for Difference, the proposed method was already 4x faster for size 100, and then it performed 7x faster for size 1000, 35x times faster for size 10,000, and 193x faster for size 100,000;
• for Union, the proposed method performs slightly faster, but gains do not visibly grow with increasing size.

The proposed implementation has improved computational complexity, lowering the complexity of Insert, Delete, and Difference from quadratic to linear:

• the complexity of Insert is O(len(s.xs)*len(xs)), and the complexity of InsertNew is O(len(s.xs)+len(xs));
• the complexity of Delete is O(len(s.xs)*len(xs)), and the complexity of DeleteNew is O(len(s.xs)+len(xs));
• the complexity of Difference is O(len(s.xs)*len(s2.xs)) because it uses Delete internally, and the complexity of DifferenceNew is O(len(s.xs)+len(s2.xs));
• the complexity of Union is harder to estimate: it involves sorting a slice of size n:=len(s.xs)+len(s2.xs), but this slice is a concatenation of two sorted slices, so most likely this does not lead to the usual O(n*log(n)) complexity; of course, it is at least O(n); the complexity of UnionNew is O(n).

EDIT: I see no obvious impact of changes applied after code review on the benchmarking results.

[DamianSawicki]

/assign joamaki

[maintainer-s-little-helper]

Commit 79ff848 does not match "(?m)^Signed-off-by:".

Please follow instructions provided in https://docs.cilium.io/en/stable/contributing/development/contributing_guide/#developer-s-certificate-of-origin

[joamaki]

Thanks! Just few non-blocking nits.

[dylandreimerink]

/test