Implement POSIX poll(2) fallback for non-epoll/kqueue platforms

The #else branch in poll.h (triggered on platforms without epoll or
kqueue — e.g. older POSIX, Haiku, Cygwin) was completely empty,
causing compilation failures. This implements the full Poll API backed
by a dynamically-resized pollfd array:

- Poll struct holds a heap-allocated pollfd array with count/capacity
- create/add/modify/remove/wait/close match epoll/kqueue semantics
- Poll_copy performs a deep copy of the fd array
- Poll_close frees the heap allocation
- Test helper updated for the new backend

Closes #4.

Author: carpentry-heartbeat[bot]

src/poll.carp

@@ -37,7 +37,8 @@ Check `readable`, `writable`, and `error?` to see what happened on `fd`.")
 (register-type Poll)
 
 (doc Poll "is an I/O event multiplexer that monitors multiple file descriptors
-for readiness. Uses kqueue on macOS/BSD and epoll on Linux.
+for readiness. Uses kqueue on macOS/BSD, epoll on Linux, and POSIX poll(2)
+as a fallback on other platforms.
 
 ## Usage
 ```

src/poll.h

@@ -233,6 +233,115 @@ void Poll_close(Poll p) {
 
 #endif /* CARP_USE_EPOLL */
 
+#ifdef CARP_USE_POLL
+
+typedef struct {
+  struct pollfd *fds;
+  int count;
+  int capacity;
+} Poll;
+
+Poll Poll_create_() {
+  Poll p;
+  p.capacity = 16;
+  p.count = 0;
+  p.fds = (struct pollfd*)CARP_MALLOC(p.capacity * sizeof(struct pollfd));
+  return p;
+}
+
+int Poll_fd_(Poll* p) {
+  /* No kernel fd — return 0 if valid, -1 if not */
+  return (p->fds != NULL) ? 0 : -1;
+}
+
+int Poll_add_(Poll* p, int fd, int interest) {
+  if (p->count >= p->capacity) {
+    int new_cap = p->capacity * 2;
+    struct pollfd *new_fds = (struct pollfd*)CARP_MALLOC(new_cap * sizeof(struct pollfd));
+    if (!new_fds) return -1;
+    memcpy(new_fds, p->fds, (size_t)p->count * sizeof(struct pollfd));
+    CARP_FREE(p->fds);
+    p->fds = new_fds;
+    p->capacity = new_cap;
+  }
+  struct pollfd *pfd = &p->fds[p->count];
+  pfd->fd = fd;
+  pfd->events = 0;
+  if (interest & POLL_READ) pfd->events |= POLLIN;
+  if (interest & POLL_WRITE) pfd->events |= POLLOUT;
+  pfd->revents = 0;
+  p->count++;
+  return 0;
+}
+
+int Poll_modify_(Poll* p, int fd, int interest) {
+  for (int i = 0; i < p->count; i++) {
+    if (p->fds[i].fd == fd) {
+      p->fds[i].events = 0;
+      if (interest & POLL_READ) p->fds[i].events |= POLLIN;
+      if (interest & POLL_WRITE) p->fds[i].events |= POLLOUT;
+      return 0;
+    }
+  }
+  errno = ENOENT;
+  return -1;
+}
+
+int Poll_remove_(Poll* p, int fd) {
+  for (int i = 0; i < p->count; i++) {
+    if (p->fds[i].fd == fd) {
+      p->fds[i] = p->fds[p->count - 1];
+      p->count--;
+      return 0;
+    }
+  }
+  errno = ENOENT;
+  return -1;
+}
+
+Array Poll_wait_(Poll* p, int timeout_ms) {
+  Array result;
+  if (!p->fds) {
+    result.len = 0; result.capacity = 0; result.data = NULL;
+    return result;
+  }
+
+  int n = poll(p->fds, (nfds_t)p->count, timeout_ms);
+  if (n < 0) {
+    result.len = 0; result.capacity = 0; result.data = NULL;
+    return result;
+  }
+
+  int ready = 0;
+  for (int i = 0; i < p->count; i++) {
+    if (p->fds[i].revents != 0) ready++;
+  }
+
+  result.len = ready;
+  result.capacity = ready > 0 ? ready : 1;
+  result.data = CARP_MALLOC(result.capacity * sizeof(PollEvent));
+
+  int j = 0;
+  for (int i = 0; i < p->count && j < ready; i++) {
+    if (p->fds[i].revents == 0) continue;
+    PollEvent* e = &((PollEvent*)result.data)[j];
+    e->fd = p->fds[i].fd;
+    e->readable = (p->fds[i].revents & POLLIN) != 0;
+    e->writable = (p->fds[i].revents & POLLOUT) != 0;
+    e->error = (p->fds[i].revents & (POLLERR | POLLHUP | POLLNVAL)) != 0;
+    j++;
+  }
+
+  result.len = j;
+  return result;
+}
+
+void Poll_close(Poll p) {
+  if (p.fds) CARP_FREE(p.fds);
+}
+
+#endif /* CARP_USE_POLL */
+
 bool Poll_wait_failed_(Array* a) {
   return a->data == NULL;
 }
@@ -243,6 +352,15 @@ Poll Poll_copy(Poll* p) {
   c.kq = p->kq;
 #elif defined(CARP_USE_EPOLL)
   c.epfd = p->epfd;
+#elif defined(CARP_USE_POLL)
+  c.count = p->count;
+  c.capacity = p->capacity;
+  if (p->fds && p->capacity > 0) {
+    c.fds = (struct pollfd*)CARP_MALLOC((size_t)p->capacity * sizeof(struct pollfd));
+    memcpy(c.fds, p->fds, (size_t)p->count * sizeof(struct pollfd));
+  } else {
+    c.fds = NULL;
+  }
 #endif
   return c;
 }

test/poll_test_helpers.h

@@ -10,6 +10,10 @@ Poll Poll_make_invalid_() {
   p.kq = -1;
 #elif defined(CARP_USE_EPOLL)
   p.epfd = -1;
+#elif defined(CARP_USE_POLL)
+  p.fds = NULL;
+  p.count = 0;
+  p.capacity = 0;
 #endif
   return p;
 }