fix: review pass — uninit stats, append crash, filter rollback, ASan leak

Address findings from the four-agent review of PR #298:

- file_create: zero the new File.matched_bytes.  It was uninitialized
  malloc memory, so the receiver could sum a garbage value into
  STATUS_STATS "Matched data" (nondeterministic --stats divergence and
  an uninitialized-heap disclosure on the wire).
- send_append: load the source into memory before hashing/copying the
  prefix and tail.  Files >64 MiB without compression (and --sendfile
  runs) are streamed without loading, so --append/--append-verify
  dereferenced a NULL data->data and crashed.
- filter_file_append: clamp the rollback to the surviving rule count.
  A "clear" rule in a merge file frees every rule including the
  caller's; the old rollback rewound count to rules_before and
  resurrected freed pointers for a double free / UAF.  Also roll back
  when set_rule_owner fails instead of leaving owner-less rules.
- filter_rule_parse: reject the xattr-name filter modifier (x), which
  was parsed and silently reinterpreted as a filename rule (affecting
  what --delete protects).  The p modifier stays accepted (existing
  grammar test).
- Remove two dead functions: compression_default_algo and
  change_render_itemize_code.
- tests: free ctx->would_delete in the two test_multiprocessing manual
  teardowns (ASan leak, 1648 bytes/run).
- docs: correct the RSYNC_COMPAT/HANDOFF tally (156 rows: 106/27/23),
  downgrade --info/--debug to caveat with their silent categories, add
  %C-vs-xxh64 and --delete-delay count caveats, refresh stale xattr
  mode comments, and document -p special-bit (setuid/setgid/sticky)
  parity plus its mitigations.

src/shared/filter.c

@@ -301,6 +301,10 @@ FilterRule* filter_rule_parse(const char* line, const FilterParseOptions* opts,
     filter_set_error(err, err_size, "the C modifier is handled by the rule-list parser");
     return NULL;
   }
+  if (xattr) {
+    filter_set_error(err, err_size, "xattr-name filter rules (the x modifier) are not supported");
+    return NULL;
+  }
   if (kind == RULE_KIND_MERGE || kind == RULE_KIND_DIR_MERGE) {
     filter_set_error(err, err_size, "merge/dir-merge rules are handled by the rule-list parser");
     return NULL;
@@ -637,6 +641,20 @@ FilterRuleList* filter_base_build(const char* const* rule_texts, int rule_count,
 
 /* ---- Per-directory merge files ---- */
 
+/* Undo the rules and dir-merge registrations that one merge file appended,
+ * leaving the caller's earlier content intact.  A "clear" rule inside the file
+ * frees every rule, including the caller's; clamp to the surviving count so
+ * those already-freed rules are never resurrected and freed a second time. */
+static void filter_file_rollback(FilterRuleList* list, int rules_before, int dir_merges_before) {
+  int first = rules_before < list->count ? rules_before : list->count;
+  for (int i = first; i < list->count; i++)
+    filter_rule_free(list->items[i]);
+  list->count = first;
+  for (int i = dir_merges_before; i < list->dir_merge_count; i++)
+    free(list->dir_merge_names[i]);
+  list->dir_merge_count = dir_merges_before;
+}
+
 bool filter_file_append(FilterRuleList* list, const char* dir_path, const char* name,
                         const char* owner_rel, const FilterParseOptions* opts, bool* exists,
                         char* err, size_t err_size) {
@@ -698,19 +716,13 @@ bool filter_file_append(FilterRuleList* list, const char* dir_path, const char*
   free(line);
   fclose(fp);
   if (!ok) {
-    /* Drop only the rules and dir-merge registrations this file appended,
-       leaving the caller's earlier content untouched. */
-    for (int i = rules_before; i < list->count; i++)
-      filter_rule_free(list->items[i]);
-    list->count = rules_before;
-    for (int i = dir_merges_before; i < list->dir_merge_count; i++)
-      free(list->dir_merge_names[i]);
-    list->dir_merge_count = dir_merges_before;
+    filter_file_rollback(list, rules_before, dir_merges_before);
     return false;
   }
   for (int i = rules_before; i < list->count; i++) {
     if (!set_rule_owner(list->items[i], owner_rel)) {
       filter_set_error(err, err_size, "memory allocation failed");
+      filter_file_rollback(list, rules_before, dir_merges_before);
       return false;
     }
   }