fix(compiler): fix Go, C++, Swift and Dart codegen bugs - #4159

With no package, a valid service Any { rpc Echo (Request) returns (Request); } now makes _service_symbol() return `Any`. Its callers append Provider, Metadata, Message, etc. afterward, producing identifiers such as `Any`Provider, which are invalid Swift; this previously emitted AnyProvider. Please keep the base unescaped and escape each complete symbol after adding its suffix. A regression case with an unqualified Any service would cover the case missed by the new keyword-package test.

Fixed in 12530bc. _service_symbol now returns the raw composed base; every emitted symbol appends a PascalCase suffix (Provider, Metadata, ...), and the complete composed name can never equal a Swift keyword, so no mid-identifier escaping can occur. Added test_swift_grpc_keyword_service_name_without_package covering an unqualified service Any (asserts AnyProvider/AnyMetadata and no backticks); it fails on the previous revision.

is_cycle_root is false for every nested call, even when the type graph has no cycle, so this also disables memoization of fully resolved acyclic dependencies. For example, declare A0 through An in that order, give each Ai two list<A(i+1)> fields, and give An an int32 field. While generating A0, both fields independently traverse the entire remaining graph because none of the successful child results are cached. The number of recursive visits grows as O(2^n), whereas the previous implementation reused each child's result. Please retain memoization for results that do not depend on a provisional cycle back-edge, and add a repeated-dependency DAG regression case alongside the cycle test.

Fixed in 12530bc. A provisional back-edge hit (message or union) now records the in-progress type in a pending-dependency set; a computed True is cached unless a pending dependency remains after the node completes, and each node discards itself from the set on completion. Acyclic traversals never take a provisional hit, so every fully resolved result memoizes and the repeated-dependency chain is linear again; cycle-tainted True results stay uncached until recomputed from a resolved root. Added test_acyclic_equatable_results_are_memoized (asserts every message in a two-fields-per-level chain lands in the cache after one root query); it fails on the previous revision.

There is still an exponential case in 12530bccc: a DAG reached after a sibling back-edge. Prepend this message to the new test's A0 through An chain and query Root with a fresh generator:

message Root {
    list<Root> children = 1;
    list<A0> data = 2;
}

Visiting children puts Root in _equatable_pending, where it stays until the entire root finishes. Consequently, the new if not self._equatable_pending condition prevents every successful Ai result from being cached, although none of those nodes depends on Root. The two fields per level still cause O(2^n) recursive visits. The new test queries the acyclic chain directly, so it misses this case. Please base cache eligibility on the current result's unresolved dependencies and add this mixed cycle/DAG case. This follows from the call path; I have not run a local timing measurement.

For list<ref TreeNode>, this now emits .list(::fory::FieldNodeSpec{}), which selects write_configured_list_data() instead of the ordinary collection writer. That configured writer never sets COLL_TRACKING_REF and passes only RefMode::None or NullOnly to the element serializer, even with global reference tracking enabled. Repeated pointers therefore lose their identity on round-trip. The existing tree fixture uses {child_a, child_a, child_b}, and the current C++ IDL job fails with IDL roundtrip failed: tree children mismatch. Please preserve reference tracking in this configured list path and make the existing IDL round-trip pass.