Add payments foundation (e-transfer/comp, Stripe config, receipts)

Implements the payments foundation for #7. Without Stripe credentials
everything works on e-transfer (pending payment confirmed by a studio
admin); when Stripe keys are configured the default flips to credit card.
Per-student override (card/etransfer/comp) is set on the student detail.

- Schema: us_payments (amount DECIMAL dollars, method, status, receipt,
  stripe intent id).
- src/Payment/: Payment VO, PaymentRepository, StudioSettings (Stripe
  options + isStripeConfigured + settings page), BillingMethodResolver
  (per-student override; default card if configured else etransfer),
  ReceiptMailer, PaymentService (create at registration, link payment_id,
  comp->paid+confirm, markPaid->confirm+receipt), PaymentController
  (e-transfer confirmation queue), PaymentEndpoint (PATCH /payments/{id}).
- Booking + enrolment create the payment from the offering price; comp
  auto-confirms the lesson; setPaymentId on both repositories.
- Admin: Studio Settings + Payments menus (manage_billing); per-student
  billing method on the student detail page.
- Docs: payments.md + README updated.

Deferred to a follow-up: the live Stripe card charge (PaymentIntent +
Stripe.js Elements + webhook + stripe/stripe-php). Until then a card
payment is created pending and confirmed like an e-transfer.

Tests: tests/Unit/Payment/ (VO, repository, resolver, service, mailer).
composer test (147), cs, and PHPStan level 6 all pass.

Refs #7

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/Unit/Payment/PaymentServiceTest.php

@@ -0,0 +1,117 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Payment;
+
+use Brain\Monkey\Functions;
+use Mockery;
+use Unsupervised\Schedular\Booking\BookingRepository;
+use Unsupervised\Schedular\Booking\Lesson;
+use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\Payment\BillingMethodResolver;
+use Unsupervised\Schedular\Payment\Payment;
+use Unsupervised\Schedular\Payment\PaymentRepository;
+use Unsupervised\Schedular\Payment\PaymentService;
+use Unsupervised\Schedular\Payment\ReceiptMailer;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class PaymentServiceTest extends TestCase
+{
+    private PaymentRepository $payments;
+    private BillingMethodResolver $resolver;
+    private ReceiptMailer $mailer;
+    private BookingRepository $bookings;
+    private EnrollmentRepository $enrollments;
+    private PaymentService $service;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->payments    = Mockery::mock(PaymentRepository::class);
+        $this->resolver    = Mockery::mock(BillingMethodResolver::class);
+        $this->mailer      = Mockery::mock(ReceiptMailer::class);
+        $this->bookings    = Mockery::mock(BookingRepository::class);
+        $this->enrollments = Mockery::mock(EnrollmentRepository::class);
+
+        $this->service = new PaymentService(
+            $this->payments,
+            $this->resolver,
+            $this->mailer,
+            $this->bookings,
+            $this->enrollments
+        );
+
+        Functions\when('get_userdata')->justReturn(false);
+    }
+
+    private function payment(string $method, string $status, int $id): Payment
+    {
+        return new Payment(5, 3, Payment::REG_LESSON, 12, 35.00, 'CAD', $method, $status, id: $id);
+    }
+
+    public function testFreeRegistrationCreatesNoPayment(): void
+    {
+        self::assertNull($this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 0.0, 'CAD'));
+    }
+
+    public function testEtransferStaysPending(): void
+    {
+        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_ETRANSFER);
+        $this->payments->shouldReceive('insert')
+            ->once()
+            ->with(Mockery::on(static fn (Payment $p): bool => $p->method === Payment::METHOD_ETRANSFER && $p->status === Payment::STATUS_PENDING))
+            ->andReturn(50);
+        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 50);
+        $this->payments->shouldReceive('findById')->with(50)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, 50));
+
+        // No markPaid / confirm for a pending e-transfer.
+        $result = $this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 35.00, 'CAD');
+
+        self::assertSame(Payment::STATUS_PENDING, $result->status);
+    }
+
+    public function testCompIsPaidAndConfirmsImmediately(): void
+    {
+        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_COMP);
+        $this->payments->shouldReceive('insert')
+            ->once()
+            ->with(Mockery::on(static fn (Payment $p): bool => $p->method === Payment::METHOD_COMP && $p->status === Payment::STATUS_PAID))
+            ->andReturn(60);
+        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 60);
+
+        $this->payments->shouldReceive('markPaid')->once()->with(60, 'USC-60')->andReturn(true);
+        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CONFIRMED)->andReturn(true);
+        $this->payments->shouldReceive('findById')->with(60)->andReturn($this->payment(Payment::METHOD_COMP, Payment::STATUS_PAID, 60));
+        $this->mailer->shouldReceive('send')->andReturn(false);
+
+        $result = $this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 35.00, 'CAD');
+
+        self::assertSame(Payment::STATUS_PAID, $result->status);
+    }
+
+    public function testMarkPaidConfirmsAndReturnsTrue(): void
+    {
+        $this->payments->shouldReceive('findById')->with(70)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, 70));
+        $this->payments->shouldReceive('markPaid')->once()->with(70, 'USC-70')->andReturn(true);
+        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CONFIRMED)->andReturn(true);
+        $this->mailer->shouldReceive('send')->andReturn(false);
+
+        self::assertTrue($this->service->markPaid(70));
+    }
+
+    public function testMarkPaidReturnsFalseWhenMissing(): void
+    {
+        $this->payments->shouldReceive('findById')->with(99)->andReturn(null);
+
+        self::assertFalse($this->service->markPaid(99));
+    }
+
+    public function testMarkPaidIdempotentWhenAlreadyPaid(): void
+    {
+        $this->payments->shouldReceive('findById')->with(80)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PAID, 80));
+
+        // Already paid → no markPaid/confirm calls.
+        self::assertTrue($this->service->markPaid(80));
+    }
+}