You need to think about this question at different levels.
You say (abbreviated for clarity) "A USB stick is hot-plugged, recognized, and its permission is rw-r--r--". When you say "recognized", what do you mean by this?
To begin with, a USB stick (or hot-plug SATA or similar hardware) is a device, specifically a block storage device. One can configure a Unix system (like FreeBSD, or like a Mac, or Linux, or ...) to do very little when a new block device shows up, namely only to detect the new hardware, and create device nodes (for example /dev/da0 and perhaps /dev/da0s1) for it. If one does that, then the kernel will do no writing to the new device, and only the amount of reading necessary to determine what the partitions or slices on the new device are: the kernel has to read /dev/da0 to get the MBR or GPT, and be able to create /dev/da0s1 or /dev/da0p1 from that read.
In practice, today's desktop operating systems are *not* configured that way. Instead, they typically run some form of automounter. That is a service (a process running somewhere, not inside the kernel, but as root and started at boot time), which monitors when new devices are created, and attempts to mount them as a file system. This is what causes a USB stick to show up in file system space as /media/... when you insert it (in addition to a device node like /dev/da0s0 being created). The process of mounting will typically write to the raw device, at least a small flag that indicates that this file system is now mounted and dirty (so if the kernel crashes before unmounting it, the next attempt to mount can detect that there may be a need to run fsck). But: This write does not change files in the file system on the device, it only changes the raw device and internal data of the file system (that is a subtle difference).
The automatic mounting of a hot-pluggable device immediately raises the question of ownership of the new device. This is a difficult and sticky problem. One viewpoint is that root runs the system, and therefore root should own the device node /dev/da0s1, and should own the mount point at which the new file system is mounted. In practice, this doesn't work well, since most USB sticks are formatted with a file system (MS-DOS a.k.a. FAT) which does not carry ownership information, so all files in that file system will look like they are owned by root. One thing I've seen on Linux desktop machines (with a running GUI) is that newly mounted USB sticks automatically get owned by whoever is logged into the GUI (on the physical console), because the auto-mounting system communicates with Gnome or KDE. While this is very practical, it is also dangerous: Unix systems are inherently multi-user, and there is no guarantee that the user who inserted the USB stick is the same account as the user on the graphical console. There is a conflict between convenience and correctness here, and any compromise will be imperfect.
At the next level, many operating systems (definitely Windows or Mac) have search assist daemons, which immediately start reading a newly mounted file system, and then write to it, creating new files. For example, on a Mac directories called ".fseventsd" and ".Spotlight..." will be created when a USB stick is inserted, and filled with files. Since these search assist daemons run as root, they can do that independent of the ownership of the file system. Since I don't run FreeBSD with a GUI, and since I have not enabled automounting, I don't know whether this will happen on a FreeBSD machine or not.
So yes, the newly mounted file system may be written to, by root, automatically. Whether it is depends on how you have configured your system.
I have never heard of a Unix system that modifies existing files upon mounting a file system, in particular not as root bypassing normal user-based access controls.
You also ask:
can an external event do a writing operation ... modifying the metadata of files stored in the filesystem (for example the timestamps informations of the files
Yes. Most file systems have a concept of "atime", the time a file has last been accessed. That atime is part of the file system metadata (stored typically in the inode of the file, which is pointed at by a directory entry in a directory object). And it is automatically updated whenever a file is read, independently of who reads it. So yes, if the newly mounted file system is being read (for example by a search assist daemon like the Spotlight thing I mentioned above), the atimes of the files will be updated, which in turn changes the metadata. Some file systems (in particular FAT) only have limited atime functionality, and file systems can be mounted with atime updates disabled.
In view of this information, I propose that you ask your question again: what do you mean by "recognized", and what do you mean by "writing"?