[wpiutil] DataLogWriter constructor doesn't throw when file cannot be created

[jwbonner]

Describe the bug
In Java, the constructor of DataLogWriter declared that it throws an IOException if the file cannot be opened. When logging to a path that doesn't exist (/U/logs/... with no USB stick attached), a native error is produced instead which crashes the robot program:

java: /work/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_ostream.cpp:582: virtual size_t wpi::raw_fd_ostream::preferred_buffer_size() const: Assertion `FD >= 0 && "File not yet open!"' failed.

This makes it difficult to utilize DataLogWriter even from a background thread, because an incidental error that would prevent logging (like a disconnected USB stick) can crash the robot program on startup. If the constructor throws an exception, this can be properly handled in user/library code.

Expected behavior
The native constructor should catch the error and propagate to Java via JNI. I haven't tested the current behavior with the non-JNI version, but if applicable it should throw a similar error.

[KangarooKoala]

I might've gotten this wrong, but I'm guessing this is what happens:

• In Java, new DataLogWriter() calls DataLogJNI.fgCreate(), whose JNI implementation creates a new DataLogWriter object.
• In DataLogWriter(wpi::Logger&, std::string_view, std::error_code&, std::string_view), we use make_unique<raw_fd_ostream>(filename, ec). If the file does not exist, ec receives a truthy value. (I would assume this is the behavior, though I haven't double checked the implementation)
• The DataLogWriter(wpi::Logger&, std::string_view, std::error_code&, std::string_view) constructor delegates to the DataLogWriter(wpi::Loger&, std::unique_pointer<wpi::raw_ostream>, std::string_view) constructor. That constructor calls StartFile(), which adds some initial buffers. (At least, I think it adds some buffers. I'm not completely sure yet)
• Within the body of the DataLogWriter constructor, because ec was assigned a truthy value, we call Stop(), which calls Flush(), inside of which we stream data into m_os. In raw_os_stream::operator<<(std::span<const uint8_t>), if there isn't already enough space, we call write(const char*, size_t), which calls SetBuffered(), which calls preferred_buffered_size(), which asserts that the file descriptor is valid.

That said, I don't know what the best fix would be.