Refactor Luhn algorithm digit processing logic

Introduced a `DigitProcessor` delegate to simplify digit processing logic.
Separated computation and validation steps into dedicated helper methods for better readability and maintainability.
Renamed `ToDigit` to `ToUnsignedIntegerDigit` for improved clarity.

Resolves: No entry

Author: shinji-san

src/LuhnAlgorithm.cs

@@ -52,6 +52,17 @@ internal static class LuhnAlgorithm
     /// </summary>
     private const int AsciiCodeForZero = 48;
 
+    /// <summary>
+    /// Represents a delegate used for processing digits within the Luhn algorithm context.
+    /// </summary>
+    /// <param name="digit">The original value of the digit before doubling.</param>
+    /// <param name="doubleDigit">The value of the digit after being doubled.</param>
+    /// <param name="index">The index of the digit in the sequence, starting from the rightmost end.</param>
+    /// <returns>
+    /// A <see cref="System.UInt32"/> representing the processed result for the current digit.
+    /// </returns>
+    private delegate uint DigitProcessor(uint digit, uint doubleDigit, int index);
+
     /// <summary>
     /// Doubles every second digit in the given sequence based on the context of validation or computation.
     /// </summary>
@@ -70,25 +81,47 @@ internal static uint DoubleEverySecondDigit(this string number, bool forValidati
 #endif
     {
         uint sum = 0;
+        DigitProcessor digitProcessor = forValidation ? ProcessDigitForValidation : ProcessDigitForComputation;
         for (int index = 0; index < number.Length; index++)
         {
-            uint digit = number[number.Length - index - 1].ToDigit();
+            uint digit = number[number.Length - index - 1].ToUnsignedIntegerDigit();
             uint doubleDigit = digit << 1;
-            if (forValidation)
-            {
-                doubleDigit = doubleDigit > 9 ? doubleDigit - 9 : doubleDigit;
-                sum += index.IsEven() ? digit : doubleDigit;
-            }
-            else
-            {
-                doubleDigit = doubleDigit / Modulus + doubleDigit % Modulus;
-                sum += !index.IsEven() ? digit : doubleDigit;
-            }
+            sum += digitProcessor(digit, doubleDigit, index);
         }
 
         return sum % Modulus;
     }
 
+    /// <summary>
+    /// Processes a digit during the computation phase of the Luhn algorithm.
+    /// Depending on the index, either the doubled digit's sum of digits or the original digit is returned.
+    /// </summary>
+    /// <param name="digit">The current digit being processed from the numeric input.</param>
+    /// <param name="doubleDigit">The value of the current digit multiplied by 2.</param>
+    /// <param name="index">The position of the digit in the sequence, considering rightmost digit as index 0.</param>
+    /// <returns>
+    /// A <see cref="System.UInt32"/> value representing the transformed digit based on its position.
+    /// </returns>
+    private static uint ProcessDigitForComputation(uint digit, uint doubleDigit, int index)
+    {
+        return !index.IsEven() ? digit : doubleDigit / Modulus + doubleDigit % Modulus;
+    }
+
+    /// <summary>
+    /// Processes a digit for validation based on the rules defined within the Luhn algorithm.
+    /// </summary>
+    /// <param name="digit">The numeric value of the digit being processed.</param>
+    /// <param name="doubleDigit">The value of the digit multiplied by two.</param>
+    /// <param name="index">The position index of the digit in the sequence, starting from zero.</param>
+    /// <returns>
+    /// A <see cref="System.UInt32"/> value representing the result of the processing based on the digit's index.
+    /// </returns>
+    private static uint ProcessDigitForValidation(uint digit, uint doubleDigit, int index)
+    {
+        doubleDigit = doubleDigit > 9 ? doubleDigit - 9 : doubleDigit;
+        return index.IsEven() ? digit : doubleDigit;
+    }
+
     /// <summary>
     /// Checks whether the <paramref name="value"/> is even.
     /// </summary>
@@ -98,9 +131,9 @@ internal static uint DoubleEverySecondDigit(this string number, bool forValidati
     private static bool IsEven(this int value) => value % 2 == 0;
 
     /// <summary>
-    /// Converts a character representing a numeric digit to its integer value.
+    /// Converts a character representing a numeric digit to its unsigned integer value.
     /// </summary>
     /// <param name="character">The character to convert. Must represent a numeric digit.</param>
     /// <returns>The numeric value of the character as an unsigned integer.</returns>
-    private static uint ToDigit(this char character) => (uint)character - AsciiCodeForZero;
+    private static uint ToUnsignedIntegerDigit(this char character) => (uint)character - AsciiCodeForZero;
 }