EC: per-file bytes cache for the FULL GET_SHARED_FILES / GET_DLOAD_QUEUE paths - #736

Supersedes the closed #731 — that PR was an early sketch that re-built the entire serialized response on any per-file change. This one is the per-file-bytes-cache design we ended up wanting: keyed off CKnownFile::s_globalEcGen per-file, so concurrent activity on one file doesn't invalidate the cached blobs for the other 90,999.

Summary

amulecmd's show shared and show DL (and any other EC_OP_GET_SHARED_FILES / EC_OP_GET_DLOAD_QUEUE request issued at EC_DETAIL_FULL with no EC_TAG_KNOWNFILE / EC_TAG_PARTFILE queryitems) iterate every file and rebuild every per-file tag tree from scratch on every invocation. On a 91k-file shareset that's the ~10 s of CPU per amulecmd show shared invocation profiled in #713 — and the work is fully wasted when the shareset hasn't changed since the previous request.

This adds a daemon-wide per-file bytes cache keyed off CKnownFile::s_globalEcGen (the change-generation counter from the INC_UPDATE work). Per file the cache holds one pre-serialized wire-format blob, freshness-stamped with the file's m_ecGen at build time. On each request:

• Snapshot the current shareset / download queue.
• For each file: reuse the cached blob if its gen still matches; otherwise build a fresh CEC_SharedFile_Tag / CEC_PartFile_Tag, serialize it via the new CECMemSocket, and store. Only the entries whose file gen advanced since the last request are rebuilt (the same per-file freshness primitive the INC_UPDATE path uses).
• Concatenate the per-file blobs and feed them through the connection's socket via SendCachedBodyResponse, which mirrors WritePacket's flag-byte / length-header / per-connection deflate dance from WriteBuffer outward — so the per-connection ZLIB-bypass on local peers still applies to the concatenated stream.

Bypassed paths (fall through to the existing live builders)

• EC_DETAIL_UPDATE — amuleweb / amulegui INC_UPDATE. Per-connection diff state by definition, not shareable.
• Requests with queryitems populated — amuleweb's phase-3 follow-up for newly discovered IDs, asking for a small filtered subset.
• Connections that didn't negotiate EC_FLAG_UTF8_NUMBERS + EC_FLAG_LARGE_TAG_COUNT (the wire format the cached blobs assume). Every modern client advertises both at auth; very old clients drop to the live path automatically.

New EC-library pieces

• CECMemSocket — a CECSocket subclass that captures all I/O into an in-memory vector. Used at build time to serialize one tag into a self-contained byte blob.
• CECSocket::SendCachedBodyResponse — public helper that emits a precomputed body (opcode + child-count + concatenated blobs) through the existing socket buffer / compression machinery.
• CECTag::Serialize — public wrapper around the protected WriteTag primitive.
• CECSocket::SetTxFlags — protected setter so daemon-internal subclasses can pre-set the per-packet wire format before invoking WriteBuffer / WriteNumber directly.
• friend class CECMemSocket on CECSocket so the mem sink can call FlushBuffers / OnOutput to drain the in-flight buffer chain.

Memory cost

~30 MB resident on a 91k library for the shared-files cache; a few KB for the download queue. Single copy daemon-wide, shared_ptr-refcounted; orphan entries pruned after each request via CECFullResponseCache::PruneOutsideOf.

Cache invalidation rate

Tracks s_globalEcGen, which bumps on every per-file change including chunk transfers. For idle / mostly-paused daemons the cache holds; busy seeders rebuild many per-file entries per second but at most one rebuild per file per change. The per-file granularity is the key win over the closed #731 whole-blob approach — activity on one file doesn't invalidate the other 90,999.

Test plan

• macOS Debug build of amuled, amulegui, amulecmd, amuleweb — clean compile.
• Loopback smoke test: small shareset, first show shared 0.446 s (cold cache build), second 0.079 s (cache hit). Same for show DL.
• Add file + reload: new file appears in next show shared; cache adapts.
• Delete file + reload: file gone; cache pruned via PruneOutsideOf.
• amulegui INC_UPDATE path stays at <5 % CPU (cache bypassed correctly — EC_DETAIL_UPDATE doesn't enter the cache branch).
• @Stoatwblr profile run on the 91k-file shareset: time amulecmd -c "show shared" should drop from ~10 s to few secs in steady state, and individual per-file changes should invalidate only that file's blob (not the whole cache).

Refs #713.