rbyd-rr: Added lfsr_tag_diverging and lfsr_tag_diverging2

If nothing else these at least makes the code a bit more readable.

Curiously this improved lfsr_rbyd_appendattr, but made the total code
size worse. I guess these really should be inlined, but don't pass some
compiler heuristic. Oh well, optimization is a hard problem:

           code          stack
  before: 34492           2864
  after:  34516 (+0.1%)   2864 (+0.0%)

                     code          frame          stack
  appendattr before: 2414            216            568
  appendattr after:  2366 (-2.0%)    216 (+0.0%)    568 (+0.0%)

lfs.c

@@ -1037,6 +1037,39 @@ static inline bool lfsr_tag_unreachable2(
             lower_tag, upper_tag);
 }
 
+static inline bool lfsr_tag_diverging(
+        lfsr_tag_t alt, lfsr_rid_t weight,
+        lfsr_srid_t lower_rid, lfsr_srid_t upper_rid,
+        lfsr_srid_t a_rid, lfsr_tag_t a_tag,
+        lfsr_srid_t b_rid, lfsr_tag_t b_tag) {
+    return lfsr_tag_follow(
+                alt, weight,
+                lower_rid, upper_rid,
+                a_rid, a_tag)
+            ^ lfsr_tag_follow(
+                alt, weight,
+                lower_rid, upper_rid,
+                b_rid, b_tag);
+}
+
+static inline bool lfsr_tag_diverging2(
+        lfsr_tag_t alt, lfsr_rid_t weight,
+        lfsr_tag_t alt2, lfsr_rid_t weight2,
+        lfsr_srid_t lower_rid, lfsr_srid_t upper_rid,
+        lfsr_srid_t a_rid, lfsr_tag_t a_tag,
+        lfsr_srid_t b_rid, lfsr_tag_t b_tag) {
+    return lfsr_tag_follow2(
+                alt, weight,
+                alt2, weight2,
+                lower_rid, upper_rid,
+                a_rid, a_tag)
+            ^ lfsr_tag_follow2(
+                alt, weight,
+                alt2, weight2,
+                lower_rid, upper_rid,
+                b_rid, b_tag);
+}
+
 
 // support for encoding/decoding tags on disk
 
@@ -2925,37 +2958,27 @@ trunk:;
                     && (((lfsr_tag_isblack(alt)
                                 // give up if we find a yellow alt
                                 || lfsr_tag_isred(p[0].alt))
-                            && lfsr_tag_follow2(
+                            && lfsr_tag_diverging2(
-                                    alt, weight,
-                                    p[0].alt, p[0].weight,
-                                    lower_rid, upper_rid,
-                                    a_rid, a_tag)
-                                ^ lfsr_tag_follow2(
                                 alt, weight,
                                 p[0].alt, p[0].weight,
                                 lower_rid, upper_rid,
+                                a_rid, a_tag,
                                 b_rid, b_tag))
                         // diverging red?
                         || (lfsr_tag_isred(p[0].alt)
-                                && lfsr_tag_follow(
+                            && lfsr_tag_diverging(
-                                        p[0].alt, p[0].weight,
-                                        lower_rid, upper_rid,
-                                        a_rid, a_tag)
-                                    ^ lfsr_tag_follow(
                                 p[0].alt, p[0].weight,
                                 lower_rid, upper_rid,
+                                a_rid, a_tag,
                                 b_rid, b_tag)))) {
                 d_state = lfsr_d_diverge(d_state);
 
                 // diverging red? flip
                 if (lfsr_tag_isred(p[0].alt)
-                        && lfsr_tag_follow(
+                        && lfsr_tag_diverging(
-                                p[0].alt, p[0].weight,
-                                lower_rid, upper_rid,
-                                a_rid, a_tag)
-                            ^ lfsr_tag_follow(
                             p[0].alt, p[0].weight,
                             lower_rid, upper_rid,
+                            a_rid, a_tag,
                             b_rid, b_tag)) {
                     if (lfsr_tag_isparallel(alt, p[0].alt)) {
                         lfsr_tag_flip2(&alt, &weight,
@@ -2971,13 +2994,10 @@ trunk:;
                     alt &= ~LFSR_TAG_R;
 
                     // both diverging? collapse
-                    if (lfsr_tag_follow(
+                    if (lfsr_tag_diverging(
-                                p[0].alt, p[0].weight,
-                                lower_rid, upper_rid,
-                                a_rid, a_tag)
-                            ^ lfsr_tag_follow(
                             p[0].alt, p[0].weight,
                             lower_rid, upper_rid,
+                            a_rid, a_tag,
                             b_rid, b_tag)) {
                         LFS_ASSERT(!lfsr_tag_isparallel(alt, p[0].alt));
                         lfsr_tag_flip2(&alt, &weight,
@@ -3022,15 +3042,11 @@ trunk:;
 
             // force diverged alts to be pruned
             } else if (lfsr_d_isdiverged(d_state)
-                    && lfsr_tag_follow2(
+                    && lfsr_tag_diverging2(
-                            alt, weight,
-                            p[0].alt, p[0].weight,
-                            lower_rid, upper_rid,
-                            a_rid, a_tag)
-                        ^ lfsr_tag_follow2(
                         alt, weight,
                         p[0].alt, p[0].weight,
                         lower_rid, upper_rid,
+                        a_rid, a_tag,
                         b_rid, b_tag)) {
                 if (lfsr_tag_follow2(
                         alt, weight,