Fix typos spotted by @a-robinson and update test failure messages to indicate…

Fix typos spotted by @a-robinson and update test failure messages to indicate that either testing failing could be due to OS SCM_RIGHTS truncation bug.

c++/src/capnp/rpc.capnp

@@ -990,7 +990,7 @@ struct CapDescriptor {
   }
 
   attachedFd @6 :UInt8 = 0xff;
-  # If the RPC message in which this CapDescriptor was delivered also had file descirptors
+  # If the RPC message in which this CapDescriptor was delivered also had file descriptors
   # attached, and `fd` is a valid index into the list of attached file descriptors, then
   # that file descriptor should be attached to this capability. If `attachedFd` is out-of-bounds
   # for said list, then no FD is attached.

c++/src/kj/async-io-test.c++

@@ -327,7 +327,11 @@ TEST(AsyncIo, ScmRightsTruncatedOdd) {
   // Second pipe should have been closed implicitly because we didn't provide space to receive it.
   KJ_NONBLOCKING_SYSCALL(n = read(in2, buffer, 4));
   if (n < 0) {
-    KJ_FAIL_ASSERT("out2 was not closed");
+    KJ_FAIL_ASSERT("out2 was not closed. This could indicate that your operating system kernel is "
+        "buggy and leaks file descriptors when an SCM_RIGHTS message is truncated. FreeBSD was "
+        "known to do this until late 2018, while MacOS still has this bug as of this writing in "
+        "2019. However, KJ works around the problem on those platforms. You need to enable the "
+        "same work-around for your OS -- search for 'SCM_RIGHTS' in src/kj/async-io-unix.c++.");
   }
   KJ_ASSERT(n == 0);
 }
@@ -409,12 +413,11 @@ TEST(AsyncIo, ScmRightsTruncatedEven) {
   // Third pipe should have been closed implicitly because we didn't provide space to receive it.
   KJ_NONBLOCKING_SYSCALL(n = read(in3, buffer, 4));
   if (n < 0) {
-    KJ_FAIL_ASSERT("out3 was not closed. If ScmRightsTruncatedOdd passed but this test failed "
-        "then your operating system kernel is buggy and leakds file descriptors when an "
-        "SCM_RIGHTS message is truncated. FreeBSD was known to do this until late 2018, while "
-        "MacOS still has this bug as of this writing in 2019. However, KJ works around the "
-        "problem on those platforms. You need to enable the same work-around for your OS -- "
-        "search for 'SCM_RIGHTS' in src/kj/async-io-unix.c++.");
+    KJ_FAIL_ASSERT("out3 was not closed. This could indicate that your operating system kernel is "
+        "buggy and leaks file descriptors when an SCM_RIGHTS message is truncated. FreeBSD was "
+        "known to do this until late 2018, while MacOS still has this bug as of this writing in "
+        "2019. However, KJ works around the problem on those platforms. You need to enable the "
+        "same work-around for your OS -- search for 'SCM_RIGHTS' in src/kj/async-io-unix.c++.");
   }
   KJ_ASSERT(n == 0);
 }

c++/src/kj/async-io.h

@@ -195,12 +195,12 @@ public:
   virtual Promise<ReadResult> tryReadWithFds(void* buffer, size_t minBytes, size_t maxBytes,
                                              AutoCloseFd* fdBuffer, size_t maxFds) = 0;
   // Read data from the stream that may have file descriptors attached. Any attached descriptors
-  // will be added to `fds`. If multiple bundles of FDs are encountered in the course of reading
-  // the amount of data requested by minBytes/maxBytes, then they will be concatenated. If more FDs
-  // are received than fit in the buffer, then the excess will be discarded and closed -- this
-  // behavior, while ugly, is important to defend against denial-of-service attacks that may fill
-  // up the FD table with garbage. Applications must think carefully about how many FDs they really
-  // need to receive at once and set a well-defined limit.
+  // will be placed in `fdBuffer`. If multiple bundles of FDs are encountered in the course of
+  // reading the amount of data requested by minBytes/maxBytes, then they will be concatenated. If
+  // more FDs are received than fit in the buffer, then the excess will be discarded and closed --
+  // this behavior, while ugly, is important to defend against denial-of-service attacks that may
+  // fill up the FD table with garbage. Applications must think carefully about how many FDs they
+  // really need to receive at once and set a well-defined limit.
 
   virtual Promise<void> writeWithStreams(ArrayPtr<const byte> data,
                                          ArrayPtr<const ArrayPtr<const byte>> moreData,