Fix concurrent append to interval with only unused segments

[kfaraz]

Bug

Concurrent append uses lock of type APPEND which always uses a lock version of epoch 1970-01-01.

This can cause data loss in a flow as follows:

• Ingest data using an APPEND task to an empty interval
• Mark all the segments as unused
• Re-run the APPEND task
• Data is not visible since old segment IDs (now unused) are allocated again

Fix

In segment allocation, do not reuse an old segment ID, used or unused.
This fix was already done for some cases back in #16380 .

An embedded test for this has been included in #18207 EmbeddedConcurrentAppendReplaceTest

---

This PR has:

• been self-reviewed.
  • using the concurrency checklist (Remove this item if the PR doesn't have any relation to concurrency.)
• added documentation for new or modified features or behaviors.
• a release note entry in the PR description.
• added Javadocs for most classes and all non-trivial methods. Linked related entities via Javadoc links.
• added or updated version, license, or notice information in licenses.yaml
• added comments explaining the "why" and the intent of the code wherever would not be obvious for an unfamiliar reader.
• added unit tests or modified existing tests to cover new code paths, ensuring the threshold for code coverage is met.
• added integration tests.
• been tested in a test Druid cluster.

[jtuglu1]

LGTM

[imply-cheddar]

This code change will append the new segment to the old set of segments. If that old set of segments had a non-zero core partition numbers, then the appended segment will carry the same set of core partitions (non-zero) and will publish the new appended segment with the extra appended partition num.

This new segment will never actually be used in queries because the core partitions will never be fully loaded by the system as it is not a complete partition of data (the semantics of the system are that the core partitions must all exist for the segments in that time range to be considered complete, extra partitions can exist, but do not have to). This means that even in the case where this showed up (a segment was dropped and then new data came in), the newly created segment won't actually be queried.

The correct fix for this is to generate a net-new version that is "better" than the previous version, adding more partitions to the unused segments is weird. IIRC, we used the static 1970 version just as a short-circuit because we weren't sure what the best version to use was in the case where nothing exists yet. At this point, we now understand why it's important to use a better version and the version of the lock should be "better" than the unused segments. Please revert this change and adjust to use a better version.