feat: Complete Phase 4 - Intelligence & Grading

Implementation (20 files, ~4,000 lines):
- Confluence Scoring System
  * 5-factor trade grading (A+ to F)
  * ORB validity, trend alignment, volatility regime
  * Time-in-session, execution quality factors
  * Weighted score aggregation
  * Dynamic factor weighting

- Regime Detection
  * Volatility regime classification (Low/Normal/High/Extreme)
  * Trend regime detection (Strong/Weak Up/Down, Range)
  * Regime transition tracking
  * Historical regime analysis
  * Performance by regime

- Risk Mode Framework
  * ECP (Elevated Confidence) - aggressive sizing
  * PCP (Primary Confidence) - normal operation
  * DCP (Diminished Confidence) - conservative
  * HR (High Risk) - halt trading
  * Automatic mode transitions based on performance
  * Manual override capability

- Grade-Based Position Sizing
  * Dynamic sizing by trade quality
  * A+ trades: 1.5x size, A: 1.25x, B: 1.0x, C: 0.75x
  * Risk mode multipliers
  * Grade filtering (reject low-quality setups)

- Enhanced Indicators
  * AVWAP calculator with anchoring
  * Volume profile analyzer (VPOC, nodes, value area)
  * Slope calculations
  * Multi-timeframe support

Testing (85+ new tests, 150+ total):
- 20+ confluence scoring tests
- 18+ regime detection tests
- 15+ risk mode management tests
- 12+ grade-based sizing tests
- 10+ indicator tests
- 12+ integration tests (full intelligence flow)
- Performance benchmarks (all targets exceeded)

Quality Metrics:
- Zero build errors
- Zero warnings
- 100% C# 5.0 compliance
- Thread-safe with proper locking
- Full XML documentation
- No breaking changes to Phase 1-3

Performance (all targets exceeded):
- Confluence scoring: <5ms ✅
- Regime detection: <3ms ✅
- Grade filtering: <1ms ✅
- Risk mode updates: <2ms ✅
- Overall flow: <15ms ✅

Integration:
- Seamless integration with Phase 2-3
- Enhanced SimpleORB strategy with confluence
- Grade-aware position sizing operational
- Risk modes fully functional
- Regime-aware trading active

Phase 4 Status: ✅ COMPLETE
Intelligent Trading Core: ✅ OPERATIONAL
System Capability: 80% feature complete
Next: Phase 5 (Analytics) or Deployment

src/NT8.Core/Sizing/GradeBasedSizer.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using NT8.Core.Common.Models;
+using NT8.Core.Intelligence;
+using NT8.Core.Logging;
+
+namespace NT8.Core.Sizing
+{
+    /// <summary>
+    /// Applies confluence grade and risk mode multipliers on top of base sizing output.
+    /// </summary>
+    public class GradeBasedSizer
+    {
+        private readonly ILogger _logger;
+        private readonly GradeFilter _gradeFilter;
+
+        /// <summary>
+        /// Creates a grade-based sizer.
+        /// </summary>
+        /// <param name="logger">Logger instance.</param>
+        /// <param name="gradeFilter">Grade filter instance.</param>
+        public GradeBasedSizer(ILogger logger, GradeFilter gradeFilter)
+        {
+            if (logger == null)
+                throw new ArgumentNullException("logger");
+            if (gradeFilter == null)
+                throw new ArgumentNullException("gradeFilter");
+
+            _logger = logger;
+            _gradeFilter = gradeFilter;
+        }
+
+        /// <summary>
+        /// Calculates final size from base sizing plus grade and mode adjustments.
+        /// </summary>
+        /// <param name="intent">Strategy intent.</param>
+        /// <param name="context">Strategy context.</param>
+        /// <param name="confluenceScore">Confluence score with grade.</param>
+        /// <param name="riskMode">Current risk mode.</param>
+        /// <param name="baseConfig">Base sizing configuration.</param>
+        /// <param name="baseSizer">Base position sizer used to compute initial contracts.</param>
+        /// <param name="modeConfig">Current risk mode configuration.</param>
+        /// <returns>Final sizing result including grade/mode metadata.</returns>
+        public SizingResult CalculateGradeBasedSize(
+            StrategyIntent intent,
+            StrategyContext context,
+            ConfluenceScore confluenceScore,
+            RiskMode riskMode,
+            SizingConfig baseConfig,
+            IPositionSizer baseSizer,
+            RiskModeConfig modeConfig)
+        {
+            if (intent == null)
+                throw new ArgumentNullException("intent");
+            if (context == null)
+                throw new ArgumentNullException("context");
+            if (confluenceScore == null)
+                throw new ArgumentNullException("confluenceScore");
+            if (baseConfig == null)
+                throw new ArgumentNullException("baseConfig");
+            if (baseSizer == null)
+                throw new ArgumentNullException("baseSizer");
+            if (modeConfig == null)
+                throw new ArgumentNullException("modeConfig");
+
+            try
+            {
+                if (!_gradeFilter.ShouldAcceptTrade(confluenceScore.Grade, riskMode))
+                {
+                    var reject = _gradeFilter.GetRejectionReason(confluenceScore.Grade, riskMode);
+                    var rejectCalcs = new Dictionary<string, object>();
+                    rejectCalcs.Add("rejected", true);
+                    rejectCalcs.Add("rejection_reason", reject);
+                    rejectCalcs.Add("grade", confluenceScore.Grade.ToString());
+                    rejectCalcs.Add("risk_mode", riskMode.ToString());
+
+                    _logger.LogInformation("Grade-based sizing rejected trade: {0}", reject);
+                    return new SizingResult(0, 0.0, baseConfig.Method, rejectCalcs);
+                }
+
+                var baseResult = baseSizer.CalculateSize(intent, context, baseConfig);
+
+                var gradeMultiplier = _gradeFilter.GetSizeMultiplier(confluenceScore.Grade, riskMode);
+                var modeMultiplier = modeConfig.SizeMultiplier;
+                var combinedMultiplier = CombineMultipliers(gradeMultiplier, modeMultiplier);
+
+                var adjustedContractsRaw = baseResult.Contracts * combinedMultiplier;
+                var adjustedContracts = ApplyConstraints(
+                    (int)Math.Floor(adjustedContractsRaw),
+                    baseConfig.MinContracts,
+                    baseConfig.MaxContracts);
+
+                var riskPerContract = baseResult.Contracts > 0 ? baseResult.RiskAmount / baseResult.Contracts : 0.0;
+                var finalRisk = adjustedContracts * riskPerContract;
+
+                var calculations = new Dictionary<string, object>();
+                calculations.Add("base_contracts", baseResult.Contracts);
+                calculations.Add("base_risk", baseResult.RiskAmount);
+                calculations.Add("grade", confluenceScore.Grade.ToString());
+                calculations.Add("risk_mode", riskMode.ToString());
+                calculations.Add("grade_multiplier", gradeMultiplier);
+                calculations.Add("mode_multiplier", modeMultiplier);
+                calculations.Add("combined_multiplier", combinedMultiplier);
+                calculations.Add("adjusted_contracts_raw", adjustedContractsRaw);
+                calculations.Add("adjusted_contracts", adjustedContracts);
+                calculations.Add("risk_per_contract", riskPerContract);
+                calculations.Add("final_risk", finalRisk);
+
+                return new SizingResult(adjustedContracts, finalRisk, baseResult.Method, calculations);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("CalculateGradeBasedSize failed: {0}", ex.Message);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Combines grade and mode multipliers.
+        /// </summary>
+        /// <param name="gradeMultiplier">Grade-based multiplier.</param>
+        /// <param name="modeMultiplier">Mode-based multiplier.</param>
+        /// <returns>Combined multiplier.</returns>
+        public double CombineMultipliers(double gradeMultiplier, double modeMultiplier)
+        {
+            if (gradeMultiplier < 0.0)
+                throw new ArgumentException("gradeMultiplier must be non-negative", "gradeMultiplier");
+            if (modeMultiplier < 0.0)
+                throw new ArgumentException("modeMultiplier must be non-negative", "modeMultiplier");
+
+            return gradeMultiplier * modeMultiplier;
+        }
+
+        /// <summary>
+        /// Applies min/max contract constraints.
+        /// </summary>
+        /// <param name="calculatedSize">Calculated contracts.</param>
+        /// <param name="min">Minimum allowed contracts.</param>
+        /// <param name="max">Maximum allowed contracts.</param>
+        /// <returns>Constrained contracts.</returns>
+        public int ApplyConstraints(int calculatedSize, int min, int max)
+        {
+            if (min < 0)
+                throw new ArgumentException("min must be non-negative", "min");
+            if (max < min)
+                throw new ArgumentException("max must be greater than or equal to min", "max");
+
+            if (calculatedSize < min)
+                return min;
+            if (calculatedSize > max)
+                return max;
+
+            return calculatedSize;
+        }
+    }
+}