Add real IMAP4rev1/POP3 implementations, DKIM/DMARC/SPF, SpamAssassin delivery hook

IMAP (RFC 3501): LOGIN through UID, previously all stubs except
CAPABILITY/LOGOUT/a partial APPEND. Multi-folder support with per-folder
UID/flag indexing (new MailFolder class, backed by .uidvalidity/.uidnext/
.imapindex sidecar files), ENVELOPE support (new MessageHeaders class:
header parsing, address-list parsing, IMAP quoting), and shared
cursor-based argument parsing (new IMAPArgs class: sequence sets, flag
lists, dates, folder-name normalization, and path-traversal protection
via isValidFolderName - a bare ".." folder name would otherwise resolve
into a sibling user's mailbox directory).

POP3 (RFC 1939): USER through QUIT, previously only CAPA. Added UIDL.
POP3 handlers use cursor-based parsing throughout rather than indexed
access - ZString's copy constructor doesn't copy its `list` field, and
POP3's dispatch passes the request by value, so indexed access into a
copy was silently reading nothing.

SMTP: DMARC evaluation added to the DATA-terminator path (DKIM
verification + alignment/policy, Authentication-Results header,
conditional rejection matching RFC 7489 6.3's p=reject + sampled pct=).
AUTH LOGIN now handles RFC 4954's optional inline initial response
(e.g. Python smtplib's "AUTH LOGIN <base64>" in one line) instead of
only the exact three-line form. Outbound relay now forces IPv4
(AF_INET) instead of AF_UNSPEC - this server's IPv4 has a correct PTR
record and SPF coverage, its IPv6 doesn't, and Gmail was rejecting
outbound mail with 550 5.7.25 as a result.

Delivery pipeline: local delivery now runs the message through
SpamAssassin (new SpamAssassinFilter class, speaking spamd's PROCESS
protocol directly over a raw socket - fails open/delivers unscanned if
spamd is unreachable) instead of a plain hardlink, since scanning can
tag/modify content.

BARANTMailConfig: extracted config loading into its own class.

compile: (see individual file changes - build script adjustments to
match the above).

Deliberately excluded from this commit: barantmail.log/
barantmail-service.log (operational logs, not source - barantmail.log
in particular was the runaway 55GB/12.9GB file from a busy-loop bug
fixed separately in ServerCore) and barantmail.cfg (this server's own
live deployment config, matching how APIServer's equivalent
config also stays untracked).

SendMail.h

@@ -1,45 +1,74 @@
 #ifndef __SendMail_h__
 #define __SendMail_h__
 
-#include "EPoll.h"
-#include "TCPSession2.h"
+#include "DKIMSigner.h"
+#include "File.h"
 #include "MString.h"
-#include "Timer.h"
-
-#define CRLF "\r\n"
-#define CRLF "\r\n"
-#ifndef ___state_defined___
-#define ___state_defined___
-typedef enum {CONNECT, READY, READYX, MAIL, RCPT, DATA, SENT} State;
-#endif
+#include <string>
+#include <vector>
 
 namespace mail {
 
-   class SendMail : public core::TCPSession2, private core::Timer {
+   ///
+   /// SendMail delivers one message to one remote recipient over
+   /// outbound SMTP (RFC 5321): resolves the recipient domain's MX
+   /// records - falling back to the domain's own address when none
+   /// exist, per RFC 5321 5.1 - tries each candidate host in preference
+   /// order until one accepts the message, and runs the client side of
+   /// the SMTP conversation (EHLO/HELO, MAIL FROM, RCPT TO, DATA with
+   /// dot-stuffing) over a plain blocking socket.
+   ///
+   /// send() is a plain, synchronous, blocking call - it does not spawn
+   /// a thread or manage this object's lifetime itself, so the exact
+   /// same class serves both of this server's real callers even though
+   /// they want opposite things: SMTPServer::inCreate() (queued mail
+   /// found via inotify) wants fire-and-forget, so it wraps its own
+   /// heap-allocated SendMail in a detached thread and deletes it when
+   /// send() returns; main.cpp's "sendmail2" CLI-injector mode wants to
+   /// block and report the result back to its caller (matching the
+   /// classic local sendmail(1) contract other programs shell out to),
+   /// so it just calls send() directly on the stack. Baking a threading
+   /// policy into this class would have made one of those two wrong.
+   ///
+   /// Every line sent and every line the remote server responds with is
+   /// appended, as it happens (not buffered to be written only at the
+   /// end - a hung or very slow remote host would otherwise leave no
+   /// trace at all until it finally times out), to one log file per
+   /// message under sendLogPath, shared across every recipient of that
+   /// message so its full delivery history reads as one transcript.
+   ///
+
+   class SendMail {
 
     public:
-      SendMail(core::EPoll &ePoll, std::string from, std::string recipient, std::string mailFileName);
-      SendMail(const SendMail &copy);
-      ~SendMail();
-      coreutils::MString& send();
+      // dkimSigner is optional (nullptr = don't sign) and not owned -
+      // the caller keeps it alive for as long as any SendMail built
+      // from it might still be sending (a shared signer is fine to
+      // reuse across many messages; it holds no per-message state).
+      SendMail(std::string hostName, std::string sendLogPath, std::string messageId,
+               coreutils::MString from, coreutils::MString recipient, coreutils::MString mailData,
+               DKIMSigner *dkimSigner = nullptr);
 
-      void protocol(coreutils::ZString &data) override;
+      /// Blocking. Returns true if some MX host for the recipient's
+      /// domain accepted the message, false if DNS resolution or every
+      /// host it tried failed.
+      bool send();
 
     private:
-      std::vector<coreutils::MString>& extractRecipientList();
-      void onTimeout() override;
+      bool deliverToHost(const std::string &host, coreutils::File &log);
+      std::vector<std::string> lookupMX(const std::string &domain);
+      std::string domainOf(coreutils::MString &address);
+      std::string readLine(int fd);
+      int readResponse(int fd, coreutils::File &log, std::string &fullText);
+      void sendLine(int fd, const std::string &line, coreutils::File &log);
 
-      core::EPoll &ePoll;
-
-      coreutils::File mailData;
+      std::string hostName;
+      std::string sendLogPath;
+      std::string messageId;
       coreutils::MString from;
       coreutils::MString recipient;
-      coreutils::MString mailFileName;
-      coreutils::MString buffer;
-      std::vector<coreutils::MString> recipientList;
-
-      State state = CONNECT;
-      State stateOnTimeout = CONNECT;
+      coreutils::MString mailData;
+      DKIMSigner *dkimSigner;
 
    };