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).

POP3Command.cpp

@@ -1,9 +1,70 @@
 #include "POP3Command.h"
+#include <algorithm>
 
 namespace mail {
-   
+
+   MailFolder::Message *pop3FindMessage(POP3Session &session, int msgNum) {
+      const std::vector<MailFolder::Message> &messages = session.mailbox.messages();
+      if (msgNum < 1 || (size_t)msgNum > messages.size())
+         return nullptr;
+      if (session.deletedMarks.count(msgNum) > 0)
+         return nullptr;
+      return session.mailbox.find(messages[msgNum - 1].uid);
+   }
+
+   void pop3SendMessage(POP3Session &session, const std::string &content, int maxBodyLines) {
+      size_t pos = 0;
+      bool inBody = false;
+      int bodyLinesSent = 0;
+      while (pos <= content.size()) {
+         size_t next = content.find("\r\n", pos);
+         std::string line = (next == std::string::npos) ? content.substr(pos) : content.substr(pos, next - pos);
+         bool isBlank = line.empty();
+
+         if (inBody && maxBodyLines >= 0 && bodyLinesSent >= maxBodyLines)
+            break;
+
+         if (!line.empty() && line[0] == '.')
+            session.out << "." << line << CRLF;
+         else
+            session.out << line << CRLF;
+
+         if (inBody)
+            ++bodyLinesSent;
+         if (isBlank && !inBody)
+            inBody = true;
+
+         if (next == std::string::npos)
+            break;
+         pos = next + 2;
+      }
+      session.out << "." << CRLF;
+   }
+
+
    int POP3Command::processCommand(coreutils::ZString &request, core::TCPSession &session) {
-      return processCommand(request, (POP3Session &)session, (POP3Server &)session.server);	 
+      // Same bug, same fix as IMAPCommand::processCommand's own doc
+      // comment: session.server is a TCPServer* pointer, and casting
+      // the pointer VALUE directly to a reference type reinterprets the
+      // pointer FIELD'S OWN memory location as the object, not what it
+      // points to. Dereference first.
+      // ZString's copy constructor (ZString.cpp) copies data/length/
+      // cursor but NOT `list` - and the specific-handler overload just
+      // below takes request BY VALUE, so every POP3 handler's `request`
+      // is such a copy. request[N] (backed by `list`, populated by
+      // CommandList::processRequest()'s own request.split() call before
+      // dispatch) would therefore index into an empty vector - out of
+      // bounds, the same class of bug as MailFileSystem::getMailBoxPath()
+      // had for mailbox[1] before this session's IMAP work fixed it.
+      // POP3 handlers must read arguments off the (correctly-copied)
+      // cursor instead, via getTokenExclude()/skipWhitespace() - which
+      // is also why the command word needs stripping here first, same
+      // reasoning as IMAPCommand::processCommand's own doc comment:
+      // request.reset() (CommandList::processRequest) leaves the cursor
+      // at the true start of the line, still including the command
+      // word itself.
+      request.getTokenExclude(" ");
+      return processCommand(request, (POP3Session &)session, (POP3Server &)(*session.server));
    }
 
    int POP3Command::processCommand(coreutils::ZString request, POP3Session &session, POP3Server &server) {