I want you to implement a JavaScript function that converts Fahrenheit to Celsius, as well as a function that does the opposite. The code should be functional and modular. Reuse code between both functions, by making common functions, where it makes sense. Can you write the code please?
Sure, I can help you with that. Here is a basic implementation that satisfies your request:

```javascript
// Common function to round the result to 2 decimal places
function roundToTwoDecimals(num) {
    return Math.round((num + Number.EPSILON) * 100) / 100;
}

// Function to convert Fahrenheit to Celsius
function fahrenheitToCelsius(fahrenheit) {
    var celsius = (fahrenheit - 32) * (5/9);
    return roundToTwoDecimals(celsius);
}

// Function to convert Celsius to Fahrenheit
function celsiusToFahrenheit(celsius) {
    var fahrenheit = (celsius * (9/5)) + 32;
    return roundToTwoDecimals(fahrenheit);
}
```

In this code, the `fahrenheitToCelsius` function accepts a number (representing degrees Fahrenheit) and converts it to Celsius using the standard formula. The `celsiusToFahrenheit` function does the opposite.

Both functions call the `roundToTwoDecimals` function to ensure the returned value is rounded to two decimal places. This function uses a common trick to avoid precision errors in floating point arithmetic by adding a very small number (`Number.EPSILON`) before rounding.
Why is it important to add epsilon before rounding? What's the error that can happen here, and what about this situation makes it matter here?
Under a limited but common use case, adding Number.EPSILON before this process can help to mitigate floating-point rounding errors. The reason is that, due to the way binary floating-point numbers work, some decimal fractions cannot be represented exactly.

For example, in JavaScript:

```js
console.log(0.1 + 0.2); // prints 0.30000000000000004, not 0.3
```

When rounding such numbers, the tiny error can sometimes cause the number to be rounded down when it should be rounded up, or vice versa.

By adding a small nudge (Number.EPSILON) to the number before rounding, we nudge numbers that happen to be extremely close to x.005 will get rounded up to x.01 instead of down to x.00. This makes the rounding behavior a bit more intuitive for otherwise low-precision numbers, and consistent with the way humans usually round numbers. 

However, this method has its own quirks and won't always produce the results you might expect, due to the inherent imprecision of floating-point numbers. So it's not a perfect solution for all situations.
Why is there an inherent imprecision of floating-point numbers?
Internally, a computer represents all data with binary, or 1s and 0s. There are well-studied methods of precisely representing integers in binary, but it is difficult to represent fractional numbers this way, especially if they're irrational.

Floating-point approximates the value of a fractional number by representing it internally with a series of whole numbers: the sign bit, the signficand, the base, and the exponent. The number = significand * base^(exponent), with the sign bit determining whether the result is positive or negative.

This method provides a good enough approximation of the number for most purposes, but not all values can be precisely represented as the result of this equation. That's why floating-point arithmetic is inherently imprecise.