When list of included libraries changes, all code should be recompiled

Bug Report

Current behavior

There is some code in place to force a recompile of everything when the compilation options change (e.g. when selecting a different board or board options). However, when the list of included libraries changes, this also changes the compiler flags, but currently this does not force a recompile of everything, meaning that some files might have been compiled with different include flags than others.

This is usually not a problem, since e.g. when removing an include from your sketch, which is not used by any other source files, this should not change behavior (and if the file is used, then the missing include will trigger the library to be included anyway).

However, this is not generally true. In particular, when multiple libraries provide the same include filename, then changing includes in e.g. your .ino file, might end up choosing a different one of these multiple libraries. If so, any other files that included that file must now be recompiled, since they were previously compiled with the other library in the include path.

See below for a complete example.

Expected behavior

It might be possible to pick out specific files to be recompiled based on the contents of the .d files, but it's probably safer and easier to just recompile everything when the list of included libraries changes.

Environment

CLI version (output of arduino-cli version): Current git master be39aa9 (arduino-cli version did not output anything meaningful)
OS and platform: Linux

Additional context

Here's an example sketch with two libraries showing the problem: IncludeChanges.zip

All contents are also shown at the bottom of this issue, for easier review. This contains two libraries A and B, both of which define a Common.h that has a func function. One accepts an int, one accepts a char, making them source compatible, but binary incompatible (i.e. any code that is recompiled will work against both, but code compiled for one will not link against the other). The sketch simply includes either library in the .ino file and has a separate .cpp file that includes Common.h and calls func(1). As you can see below, changing from library A to B does not cause a recompile of test.cpp and breaks the build.

IncludeChanges$ cat IncludeChanges.ino
#include <A.h>

void loop() { };
IncludeChanges$ arduino-cli compile --libraries libraries -v | grep  previously.*sketch/

... Changed include using editor ...

IncludeChanges$ cat IncludeChanges.ino
#include <B.h>

void loop() { };
IncludeChanges$ arduino-cli compile --libraries libraries -v | grep  previously.*sketch/
Using previously compiled file: /tmp/arduino-sketch-E34A9943CF606AE3061B946D36F3A4EE/sketch/test.cpp.o
/tmp/ccaQVdvp.ltrans0.ltrans.o: In function `setup':
/tmp/arduino-sketch-E34A9943CF606AE3061B946D36F3A4EE/sketch/test.cpp:5: undefined reference to `func(int)'
collect2: error: ld returned 1 exit status
Error during build: exit status 1

IncludeChanges$ tree
.
├── IncludeChanges.ino
├── libraries
│   ├── A
│   │   ├── A.h
│   │   ├── Common.cpp
│   │   └── Common.h
│   └── B
│       ├── B.h
│       ├── Common.cpp
│       └── Common.h
├── sketch.json
└── test.cpp

3 directories, 9 files
IncludeChanges$ for f in $(find -type f); do echo $f; cat $f | sed 's/^/  /'; echo; done
./test.cpp
  #include <Arduino.h>
  #include <Common.h>

  void setup() {
      func(1);
  }

./libraries/A/Common.cpp
  void func(int) { }

./libraries/A/A.h

./libraries/A/Common.h
  void func(int);

./libraries/B/Common.cpp
  void func(char) { }

./libraries/B/B.h

./libraries/B/Common.h
  void func(char);

./IncludeChanges.ino
  #include <B.h>

  void loop() { };

./sketch.json
  {
    "cpu": {
      "fqbn": "arduino:avr:uno",
      "port": ""
    }
  }

arduino / arduino-cli