Zero-init planner structs via value-init instead of memset

cppcheck flags memset(0) on structs containing doubles (memsetClassFloat)
as non-portable. Use C++ value-initialization (`T x{};`, `*ptr = T{};`)
instead: for these POD structs it compiles to the same zeroing, is
portable (no reliance on all-zero-bits == 0.0), and clears the warning
legitimately rather than suppressing it.

Author: grandixximo

src/emc/motion_planning/blend_sizing.cc

@@ -970,7 +970,7 @@ int optimizeBlendSize9(TC_STRUCT const * const prev_tc,
         return TP_ERR_MISSING_INPUT;
     }
 
-    memset(result, 0, sizeof(BlendSolution9));
+    *result = BlendSolution9{};
     result->status = BLEND9_FAIL;
 
     /* Get maximum blend region */
@@ -1157,7 +1157,7 @@ int createBlendSegment9(TC_STRUCT const * const prev_tc,
     }
 
     /* Zero-initialize */
-    memset(blend_tc, 0, sizeof(TC_STRUCT));
+    *blend_tc = TC_STRUCT{};
 
     /* Initialize as TC_BEZIER */
     tcInit(blend_tc,

src/emc/motion_planning/motion_planning_9d.cc

@@ -2875,10 +2875,8 @@ bool computeBranch(TP_STRUCT *tp, TC_STRUCT *tc, double new_feed_scale,
         // Store cascade info
         tc->shared_9d.requested_feed_scale = new_feed_scale;
 
-        ruckig_profile_t brake_profile;
-        ruckig_profile_t main_profile;
-        memset(&brake_profile, 0, sizeof(brake_profile));
-        memset(&main_profile, 0, sizeof(main_profile));
+        ruckig_profile_t brake_profile{};
+        ruckig_profile_t main_profile{};
 
         double brake_end_position = state.position;  // Position after brake (relative to segment start)
 
@@ -2926,8 +2924,7 @@ bool computeBranch(TP_STRUCT *tp, TC_STRUCT *tc, double new_feed_scale,
                     double safe_acc = sqrt(2.0 * sv * default_jerk);
                     if (tc->maxaccel > safe_acc + 0.5) {
                         input.max_acceleration = {safe_acc};
-                        ruckig_profile_t constrained;
-                        memset(&constrained, 0, sizeof(constrained));
+                        ruckig_profile_t constrained{};
                         auto r2 = otg.calculate(input, traj);
                         if (r2 == ruckig::Result::Working || r2 == ruckig::Result::Finished) {
                             copyRuckigProfile(traj, &constrained);
@@ -3880,8 +3877,7 @@ static int writeSpillOverStopProfiles(TP_STRUCT *tp, TC_STRUCT *tc,
             if (result != ruckig::Result::Working &&
                 result != ruckig::Result::Finished) break;
 
-            ruckig_profile_t stop_profile;
-            memset(&stop_profile, 0, sizeof(stop_profile));
+            ruckig_profile_t stop_profile{};
             copyRuckigProfile(traj, &stop_profile);
             if (!stop_profile.valid ||
                 profileHasNegativeVelocity(&stop_profile)) {
@@ -3893,7 +3889,7 @@ static int writeSpillOverStopProfiles(TP_STRUCT *tp, TC_STRUCT *tc,
                     result = otg.calculate(input, traj);
                     if (result == ruckig::Result::Working ||
                         result == ruckig::Result::Finished) {
-                        memset(&stop_profile, 0, sizeof(stop_profile));
+                        stop_profile = {};
                         copyRuckigProfile(traj, &stop_profile);
                     }
                 }

src/emc/motion_planning/motion_planning_9d_userspace.cc

@@ -294,7 +294,7 @@ static int tcInit_9D(TC_STRUCT * const tc,
 {
     if (!tc) return -1;
 
-    memset(tc, 0, sizeof(TC_STRUCT));
+    *tc = TC_STRUCT{};
 
     tc->motion_type = motion_type;
     tc->canon_motion_type = canon_motion_type;
@@ -754,9 +754,7 @@ static int tpSetupBlend9D(TP_STRUCT *tp, TC_STRUCT *prev_tc, TC_STRUCT *tc)
 
     // Build per-axis velocity and acceleration bounds
     // Use minimum of both segments' limits
-    AxisBounds9 vel_bounds, acc_bounds;
-    memset(&vel_bounds, 0, sizeof(vel_bounds));
-    memset(&acc_bounds, 0, sizeof(acc_bounds));
+    AxisBounds9 vel_bounds{}, acc_bounds{};
 
     double v_min = fmin(prev_tc->maxvel, tc->maxvel);
     double a_min = fmin(prev_tc->maxaccel, tc->maxaccel);
@@ -803,8 +801,7 @@ static int tpSetupBlend9D(TP_STRUCT *tp, TC_STRUCT *prev_tc, TC_STRUCT *tc)
                 // Compute Jacobian at junction for non-identity kinematics
                 if (g_userspace_kins_planner.isEnabled() &&
                     !g_userspace_kins_planner.isIdentity()) {
-                    EmcPose junction;
-                    memset(&junction, 0, sizeof(junction));
+                    EmcPose junction{};
                     if (tc->motion_type == TC_LINEAR) {
                         junction.tran = tc->coords.line.xyz.start;
                         junction.a = tc->coords.line.abc.start.x;
@@ -1236,8 +1233,7 @@ static void tpComputeKinkVelocity_9D(TP_STRUCT *tp, TC_QUEUE_STRUCT *queue,
     bool have_jacobian = false;
     if (g_userspace_kins_planner.isEnabled() &&
         !g_userspace_kins_planner.isIdentity()) {
-        EmcPose junction;
-        memset(&junction, 0, sizeof(junction));
+        EmcPose junction{};
         if (tc->motion_type == TC_LINEAR) {
             junction.tran = tc->coords.line.xyz.start;
             junction.a = tc->coords.line.abc.start.x;