EC: skip unchanged files in INC_UPDATE for big-library performance - #727

Wires `MarkECChanged()` into each storage primitive that writes a field
exported via `CEC_SharedFile_Tag` / `CEC_PartFile_Tag`. Still no behavior
change on the EC dispatch side — the next commit consumes the flag.

Sites covered:

  * `CFileStatistic::AddRequest / AddAccepted / AddTransferred`
    (EC_TAG_KNOWNFILE_REQ_COUNT, _ACCEPT_COUNT, _XFERRED and their _ALL
    counterparts). `AddTransferred` is the hottest of the three —
    every uploaded chunk flips the flag. The Mark op is a single
    atomic fetch_add+store so the cost is small even on multi-slot
    upload nodes.
  * `CKnownFile::AddUploadingClient / RemoveUploadingClient`
    (EC_TAG_KNOWNFILE_ON_QUEUE = m_ClientUploadList.size()).
  * `CKnownFile::SetFileName` (EC_TAG_PARTFILE_NAME and ed2k:// link).
  * `CKnownFile::SetFilePath` (EC_TAG_KNOWNFILE_FILENAME on non-partfiles).
  * `CKnownFile::SetUpPriority / SetAutoUpPriority` (EC_TAG_KNOWNFILE_PRIO,
    which folds the auto flag in as +10).
  * `CKnownFile::SetFileCommentRating` (EC_TAG_KNOWNFILE_COMMENT / _RATING).
  * `CKnownFile::UpdatePartsInfo` (EC_TAG_KNOWNFILE_COMPLETE_SOURCES{,LOW,HIGH}).
  * `m_pAICHHashSet->SetMasterHash` call sites in KnownFile.cpp /
    PartFile.cpp and `SetAICHHashset` swap in amule.cpp's hash-task
    completion (EC_TAG_KNOWNFILE_AICH_MASTERHASH).
  * `CPartFile::Process` — coarse hook at the per-second per-partfile
    tick. Partfiles have ~20 EC-exported fields that change
    independently on active downloads; the per-second tick is the
    right granularity and avoids hooking each of them.

A 60 s periodic backstop in commit (3/3) catches anything missed here.

Refs amule-project#713.

Consumes the per-file `m_ecGen` from commit (1/3) and the `MarkECChanged`
hooks from commit (2/3): `Get_EC_Response_GetUpdate` now skips files
whose generation is at or below the highest gen this connection has
already reflected in its `CObjTagMap`. For a 91 k-file shareset with a
few hundred actively-transferring files at any moment, the per-cycle
iteration goes from O(N) to O(files-that-actually-changed) — typically
a 99 %+ reduction.

Mechanism per connection:

  * snapshot = CKnownFile::s_globalEcGen at request start
  * threshold = m_lastEcGenSeen carried from the previous response
  * iterate only files where file.m_ecGen > threshold
  * m_lastEcGenSeen := snapshot after iteration
  * files whose m_ecGen changes mid-iteration land above the snapshot
    and get picked up on the next request

Backstop: every kFullEcSyncIntervalSeconds (60 s) every connection
runs an unconditional full sweep regardless of gen. Worst-case
staleness if a `MarkECChanged()` hook was missed somewhere is bounded
to that interval rather than indefinite. The interval is short enough
to keep amulegui's UI from drifting noticeably and long enough that
the 99 % skip win still dominates the per-cycle workload.

Wire format unchanged; INC_UPDATE responses now contain only the
files that changed since the last response, which is exactly what the
delta protocol was designed to convey but the implementation used to
emit empty tag bodies for unchanged files anyway. Backwards-compatible
with any client version (the client side already correctly handles
missing-file-tag = "no change").

Refs amule-project#713.

…t-in

Commit 3 broke amulegui on big libraries because amulegui infers
deletions from absence: any file ID missing from an INC_UPDATE response
is removed from the local view. Skipping unchanged files entirely meant
most of the shareset disappeared every cycle (then the 5-min backstop
re-added them), wedging the GUI's list-widget at 100% CPU in
std::unordered_map churn.

Two-pronged fix preserving the optimization in both compat and opt-in
paths:

* Backward compat (old amulegui / amuleweb / third-party client):
  unchanged files get a 5-byte "alive marker" tag — EC_TAG_KNOWNFILE /
  EC_TAG_PARTFILE with the ECID and no children. The legacy client
  already gates updates on `if (tag->HasChildTags())`, so empty tags
  count as "present" without triggering the per-item update. Keeps the
  expensive CEC_SharedFile_Tag construction + encoder pass off the
  hot path (the actual perf win); only pays a tiny per-file wire cost.

* Partial-update protocol opt-in:
  - New EC_TAG_CAN_PARTIAL_UPDATE capability advertised by the client
    at auth, mirrored back by the server in AUTH_OK if it understands
    the protocol.
  - When negotiated, server skips unchanged files entirely and emits
    explicit EC_TAG_FILE_REMOVED markers (top-level, value = ECID)
    for files that disappeared since the previous cycle.
    CECServerSocket tracks the previous cycle's snapshot in
    m_lastSentFileIds.
  - amulegui clients in this mode skip the bulk "missing == deleted"
    loop and process explicit removals only.

Also drops the 5-minute paranoia backstop. With explicit removal
markers and alive markers covering both protocol paths, the backstop's
only remaining job was hiding missed MarkECChanged() hooks — making
those bugs harder to find rather than easier.

Negotiation matrix:
  new server + new client → partial-update (full win, ~0 work
    per-cycle for static files)
  new server + old client → alive markers (almost full win, cheap
    per-file wire cost)
  old server + new client → server ignores capability, doesn't mirror
    it back; client falls back to bulk-deletion path
  old server + old client → unchanged

amuleweb drives its INC_UPDATE polling through `EC_OP_GET_SHARED_FILES`
+ `EC_OP_GET_DLOAD_QUEUE` with `EC_DETAIL_UPDATE` rather than the
`EC_OP_GET_UPDATE` path amulegui uses. Commit (4/5) wired the partial-
update protocol only into `Get_EC_Response_GetUpdate`, so amuleweb
kept iterating all files every cycle even on huge libraries.

Extend the same skip-unchanged + `EC_TAG_FILE_REMOVED` logic into
`Get_EC_Response_GetSharedFiles` and `Get_EC_Response_GetDownloadQueue`,
guarded on the same `m_partialUpdateActive` flag and only kicking in
for `EC_DETAIL_UPDATE` requests (so amulecmd's `show shared` and other
`EC_DETAIL_FULL` callers are untouched).

Per-path state because the three handlers fire on independent cadences:

* `m_lastEcGenSeen`        + `m_lastSentFileIds`        — amulegui's
  `EC_OP_GET_UPDATE`
* `m_lastEcGenSeenShared`  + `m_lastSentSharedFileIds`  — amuleweb's
  `EC_OP_GET_SHARED_FILES`
* `m_lastEcGenSeenPart`    + `m_lastSentPartFileIds`    — amuleweb's
  `EC_OP_GET_DLOAD_QUEUE`

amuleweb's `UpdatableItemsContainer::ProcessUpdate` learns the same
two-path behaviour: when the negotiated capability is active, drain
`EC_TAG_FILE_REMOVED` markers into a buffered removal set and run a
single sweep over the live list only when removals exist; otherwise
the legacy "missing == deleted" loop stays correct (server still emits
diff-empty alive-marker tags via the existing encoder path).

`CaMuleExternalConnector::IsServerPartialUpdateActive()` exposes
`CRemoteConnect::ServerSupportsPartialUpdate()` to the container.

Compat matrix unchanged from (4/5): the negotiation is symmetric, so
old amuleweb + new amuled and new amuleweb + old amuled both fall back
to the legacy path automatically.

…ction setters

Reverse audit of every EC_DETAIL_UPDATE field surfaced nine mutation
sites that change exported state without marking the partfile changed.
For an active partfile the per-tick `MarkECChanged()` at the top of
`CPartFile::Process()` covered them implicitly, but `DownloadQueue::
Process()` gates `Process()` to `PS_READY`/`PS_EMPTY` only — paused,
stopped, hashing, and completed partfiles never auto-mark, so a user
toggling pause/resume/priority/category from amulegui or amuleweb
would stay invisible until something else on the file changed.
The 5-minute paranoia backstop (removed in 4/5) used to paper over
this; explicit hooks are the correct fix.

Sites covered:

* `CPartFile::StopFile`              — EC_TAG_PARTFILE_STOPPED / _STATUS
* `CPartFile::PauseFile`             — EC_TAG_PARTFILE_STOPPED / _STATUS
* `CPartFile::ResumeFile`            — EC_TAG_PARTFILE_STOPPED / _STATUS
* `CPartFile::SetDownPriority`       — EC_TAG_PARTFILE_PRIO
* `CPartFile::SetAutoDownPriority`   — EC_TAG_PARTFILE_PRIO (auto flag
                                        folded in via +10 offset)
* `CPartFile::SetA4AFAuto`           — EC_TAG_PARTFILE_A4AFAUTO
* `CPartFile::SetCategory`           — EC_TAG_PARTFILE_CAT
* `CPartFile::SetHashingProgress`    — EC_TAG_PARTFILE_HASHED_PART_COUNT
                                        (runs during hashing, outside
                                        Process()'s gate)
* `CPartFile::UpdateFileRatingCommentAvail` — EC_TAG_PARTFILE_COMMENTS
                                        (fires when sources deliver
                                        ratings/comments via OP_MESSAGE)

All hooks are conditional on actual value change to keep the
generation counter from incrementing on no-op writes.