fix(c#): retain SimpleLabel importance weight when building examples (#4949)

SimpleLabelUpdateExample wrote the importance weight to example::weight, but
that field is not where a simple label's weight lives. VW::setup_example --
which VowpalWabbitExampleBuilder.CreateExample runs to finalize the example --
reassigns it:

  ae->weight = lbl_parser.get_weight(ae->l, ae->ex_reduction_features);

and for simple labels get_weight returns simple_label_reduction_features::weight,
which ApplyLabel never set. So the weight was overwritten with its default of 1
between ApplyLabel and CreateExample, and SimpleLabelReadFromExample -- which
reads the reduction feature, and was correct all along -- reported 1.

Reported in #4945: a label built as { Label = 7, Weight = 4, Initial = 3 } reads
back as 7 1 3. StringLabel is unaffected because the text parser writes
simple_red_features.weight directly, which is why it round-trips correctly and
made the two paths disagree.

The consequence is worse than a bad round-trip: because ex->weight is what the
learner consumes, an importance weight supplied through SimpleLabel never
reached training at all -- every such example trained as though weighted 1.0.

Set the reduction feature, which is the source of truth and survives
setup_example, and keep assigning ex->weight so the value is also correct for
callers that never run setup_example.

Verified by driving the same native entry points the builder uses
(SimpleLabelUpdateExample -> VW::setup_example -> SimpleLabelReadFromExample):
before the change the harness reports "label=7 weight=1 initial=3", matching the
report exactly; after it reports "label=7 weight=4 initial=3" with ex->weight=4.

Adds two regression tests mirroring the reporter's: one that the weight
round-trips, and one that it actually affects training.

Closes #4945

Claude-Session: https://claude.ai/code/session_01EVprwZHP4KXAhsF6JGXK9k

Author: JohnLangford

cs/unittest/TestLabels.cs

@@ -81,6 +81,81 @@ public void TestStringLabels()
             }
         }
 
+
+        /// <summary>
+        /// Regression test for #4945. SimpleLabelUpdateExample wrote the importance weight to
+        /// example::weight, but VW::setup_example -- which the builder runs inside CreateExample --
+        /// reassigns that field from the simple-label reduction features, so the weight was
+        /// overwritten with the default of 1 before anything could read it back. StringLabel was
+        /// unaffected because the text parser writes the reduction feature directly.
+        /// </summary>
+        [TestMethod]
+        [TestCategory("Vowpal Wabbit")]
+        public void TestSimpleLabelRetainsWeight()
+        {
+            using (var vw = new VowpalWabbit("--quiet"))
+            using (var builder = new VowpalWabbitExampleBuilder(vw))
+            {
+                builder.ApplyLabel(new SimpleLabel { Label = 7f, Weight = 4f, Initial = 3f });
+
+                using (var example = builder.CreateExample())
+                {
+                    var read = (SimpleLabel)example.Label;
+                    Assert.AreEqual(7f, read.Label, "label");
+                    Assert.AreEqual(4f, read.Weight, "weight");
+                    Assert.AreEqual(3f, read.Initial, "initial");
+                }
+            }
+        }
+
+        /// <summary>
+        /// The consequence of the above: a weight that never reaches the learner trains as though
+        /// it were 1.0, so these two produced identical predictions before the fix.
+        /// </summary>
+        [TestMethod]
+        [TestCategory("Vowpal Wabbit")]
+        public void TestSimpleLabelWeightAffectsTraining()
+        {
+            Func<ILabel, float> train = label =>
+            {
+                using (var vw = new VowpalWabbit("--link logistic --loss_function logistic -b 18 --quiet"))
+                {
+                    using (var builder = new VowpalWabbitExampleBuilder(vw))
+                    {
+                        using (var ns = builder.AddNamespace('a'))
+                        {
+                            ns.AddFeature(vw.HashFeature("x", vw.HashSpace("a")), 1f);
+                        }
+
+                        builder.ApplyLabel(label);
+
+                        using (var example = builder.CreateExample())
+                        {
+                            vw.Learn(example);
+                        }
+                    }
+
+                    using (var scoreBuilder = new VowpalWabbitExampleBuilder(vw))
+                    {
+                        using (var ns = scoreBuilder.AddNamespace('a'))
+                        {
+                            ns.AddFeature(vw.HashFeature("x", vw.HashSpace("a")), 1f);
+                        }
+
+                        using (var scored = scoreBuilder.CreateExample())
+                        {
+                            return vw.Predict(scored, VowpalWabbitPredictionType.Scalar);
+                        }
+                    }
+                }
+            };
+
+            var heavy = train(new SimpleLabel { Label = 1f, Weight = 4f });
+            var light = train(new SimpleLabel { Label = 1f, Weight = 0.05f });
+
+            Assert.AreNotEqual(heavy, light,
+                "importance weight had no effect on training: both behaved as weight 1.0");
+        }
     }
 
     public class SimpleContext

cs/vw.net.native/vw.net.labels.cc

@@ -20,12 +20,21 @@ API void SimpleLabelUpdateExample(vw_net_native::workspace_context* workspace, V
   auto* ld = &ex->l.simple;
   ld->label = label;
 
-  if (maybe_weight) { ex->weight = *maybe_weight; }
-
-  if (maybe_initial)
+  // The importance weight lives in the simple-label reduction features, not on the example.
+  // VW::setup_example assigns ex->weight from lbl_parser.get_weight(), which for simple labels
+  // reads simple_label_reduction_features::weight -- so writing only ex->weight here was silently
+  // discarded when the builder finalized the example, leaving the default weight of 1.
+  // Set both: the reduction feature is the source of truth and survives setup_example, while
+  // ex->weight keeps the value correct for callers that never run setup_example.
+  if (maybe_weight || maybe_initial)
   {
     auto& red_fts = ex->ex_reduction_features.template get<VW::simple_label_reduction_features>();
-    red_fts.initial = *maybe_initial;
+    if (maybe_weight)
+    {
+      red_fts.weight = *maybe_weight;
+      ex->weight = *maybe_weight;
+    }
+    if (maybe_initial) { red_fts.initial = *maybe_initial; }
   }
 
   VW::count_label(*workspace->vw->sd, ld->label);